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/android/media_session.h" | 5 #include "content/browser/media/android/media_session.h" |
6 | 6 |
7 #include <list> | 7 #include <list> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "content/browser/media/android/media_session_observer.h" | 10 #include "content/browser/media/android/media_session_observer.h" |
| 11 #include "content/public/browser/web_contents.h" |
| 12 #include "content/public/browser/web_contents_delegate.h" |
11 #include "content/public/test/content_browser_test.h" | 13 #include "content/public/test/content_browser_test.h" |
12 #include "content/shell/browser/shell.h" | 14 #include "content/shell/browser/shell.h" |
13 | 15 |
14 namespace content { | 16 using content::WebContents; |
| 17 using content::WebContentsDelegate; |
| 18 using content::MediaSession; |
| 19 using content::MediaSessionObserver; |
| 20 |
| 21 namespace { |
15 | 22 |
16 class MockMediaSessionObserver : public MediaSessionObserver { | 23 class MockMediaSessionObserver : public MediaSessionObserver { |
17 public: | 24 public: |
18 MockMediaSessionObserver() | 25 MockMediaSessionObserver() |
19 : received_resume_calls_(0), | 26 : received_resume_calls_(0), |
20 received_suspend_calls_(0) { | 27 received_suspend_calls_(0) { |
21 } | 28 } |
22 | 29 |
23 ~MockMediaSessionObserver() override = default; | 30 ~MockMediaSessionObserver() override = default; |
24 | 31 |
25 // Implements MediaSessionObserver. | 32 // Implements MediaSessionObserver. |
26 void OnSuspend(int player_id) override { | 33 void OnSuspend(int player_id) override { |
27 DCHECK(player_id >= 0); | 34 DCHECK(player_id >= 0); |
28 DCHECK(players_.size() > static_cast<size_t>(player_id)); | 35 DCHECK(players_.size() > static_cast<size_t>(player_id)); |
29 | 36 |
30 ++received_suspend_calls_; | 37 ++received_suspend_calls_; |
31 players_[player_id] = false; | 38 players_[player_id] = false; |
32 } | 39 } |
| 40 |
33 void OnResume(int player_id) override { | 41 void OnResume(int player_id) override { |
34 DCHECK(player_id >= 0); | 42 DCHECK(player_id >= 0); |
35 DCHECK(players_.size() > static_cast<size_t>(player_id)); | 43 DCHECK(players_.size() > static_cast<size_t>(player_id)); |
36 | 44 |
37 ++received_resume_calls_; | 45 ++received_resume_calls_; |
38 players_[player_id] = true; | 46 players_[player_id] = true; |
39 } | 47 } |
40 | 48 |
41 int StartNewPlayer() { | 49 int StartNewPlayer() { |
42 players_.push_back(true); | 50 players_.push_back(true); |
(...skipping 20 matching lines...) Expand all Loading... |
63 | 71 |
64 private: | 72 private: |
65 // Basic representation of the players. The position in the vector is the | 73 // Basic representation of the players. The position in the vector is the |
66 // player_id. The value of the vector is the playing status. | 74 // player_id. The value of the vector is the playing status. |
67 std::vector<bool> players_; | 75 std::vector<bool> players_; |
68 | 76 |
69 int received_resume_calls_; | 77 int received_resume_calls_; |
70 int received_suspend_calls_; | 78 int received_suspend_calls_; |
71 }; | 79 }; |
72 | 80 |
73 class MediaSessionBrowserTest : public ContentBrowserTest { | 81 class MockWebContentsDelegate : public WebContentsDelegate { |
| 82 public: |
| 83 explicit MockWebContentsDelegate(WebContents* web_contents) |
| 84 : web_contents_(web_contents), |
| 85 update_counter_(0) { |
| 86 } |
| 87 |
| 88 void UpdateMediaControls(WebContents* web_contents) override { |
| 89 EXPECT_EQ(web_contents_, web_contents); |
| 90 ++update_counter_; |
| 91 } |
| 92 |
| 93 int update_counter() const { return update_counter_; } |
| 94 |
| 95 private: |
| 96 WebContents* web_contents_; |
| 97 int update_counter_; |
| 98 |
| 99 DISALLOW_COPY_AND_ASSIGN(MockWebContentsDelegate); |
| 100 }; |
| 101 |
| 102 } // namespace |
| 103 |
| 104 class MediaSessionBrowserTest : public content::ContentBrowserTest { |
74 protected: | 105 protected: |
75 MediaSessionBrowserTest() = default; | 106 MediaSessionBrowserTest() = default; |
76 | 107 |
77 void DisableNativeBackend(MediaSession* media_session) { | 108 void SetUpOnMainThread() override { |
78 media_session->ResetJavaRefForTest(); | 109 ContentBrowserTest::SetUpOnMainThread(); |
| 110 |
| 111 mock_web_contents_delegate_.reset( |
| 112 new MockWebContentsDelegate(shell()->web_contents())); |
| 113 previous_delegate_ = shell()->web_contents()->GetDelegate(); |
| 114 shell()->web_contents()->SetDelegate(mock_web_contents_delegate_.get()); |
| 115 media_session_ = MediaSession::Get(shell()->web_contents()); |
| 116 media_session_->ResetJavaRefForTest(); |
| 117 ASSERT_TRUE(media_session_); |
79 } | 118 } |
80 | 119 |
81 void StartNewPlayer(MediaSession* media_session, | 120 void TearDownOnMainThread() override { |
82 MockMediaSessionObserver* media_session_observer, | 121 media_session_->RemoveAllPlayersForTest(); |
| 122 media_session_ = nullptr; |
| 123 |
| 124 shell()->web_contents()->SetDelegate(previous_delegate_); |
| 125 |
| 126 ContentBrowserTest::TearDownOnMainThread(); |
| 127 } |
| 128 |
| 129 void StartNewPlayer(MockMediaSessionObserver* media_session_observer, |
83 MediaSession::Type type) { | 130 MediaSession::Type type) { |
84 bool result = media_session->AddPlayer( | 131 bool result = AddPlayer( |
85 media_session_observer, | 132 media_session_observer, media_session_observer->StartNewPlayer(), type); |
86 media_session_observer->StartNewPlayer(), | |
87 type); | |
88 EXPECT_TRUE(result); | 133 EXPECT_TRUE(result); |
89 } | 134 } |
90 | 135 |
91 void SuspendSession(MediaSession* media_session) { | 136 bool AddPlayer(MockMediaSessionObserver* media_session_observer, |
92 media_session->OnSuspend(true); | 137 int player_id, |
| 138 MediaSession::Type type) { |
| 139 return media_session_->AddPlayer(media_session_observer, player_id, type); |
93 } | 140 } |
94 | 141 |
95 void ResumeSession(MediaSession* media_session) { | 142 void RemovePlayer( |
96 media_session->OnResume(); | 143 MockMediaSessionObserver* media_session_observer, int player_id) { |
| 144 media_session_->RemovePlayer(media_session_observer, player_id); |
97 } | 145 } |
98 | 146 |
99 bool HasAudioFocus(MediaSession* media_session) { | 147 void RemovePlayers( |
100 return media_session->IsActiveForTest(); | 148 MockMediaSessionObserver* media_session_observer) { |
| 149 media_session_->RemovePlayers(media_session_observer); |
101 } | 150 } |
102 | 151 |
103 MediaSession::Type GetSessionType(MediaSession* media_session) { | 152 void SuspendSession(bool isTemporary) { |
104 return media_session->audio_focus_type_for_test(); | 153 media_session_->OnSuspend(nullptr, nullptr, isTemporary); |
105 } | 154 } |
106 | 155 |
107 private: | 156 void ResumeSession() { |
| 157 media_session_->OnResume(nullptr, nullptr); |
| 158 } |
| 159 |
| 160 bool HasAudioFocus() { |
| 161 return media_session_->IsActiveForTest(); |
| 162 } |
| 163 |
| 164 MediaSession::Type GetSessionType() { |
| 165 return media_session_->audio_focus_type_for_test(); |
| 166 } |
| 167 |
| 168 bool IsControllable() { |
| 169 return media_session_->IsControllable(); |
| 170 } |
| 171 |
| 172 bool IsPaused() { |
| 173 return media_session_->IsPaused(); |
| 174 } |
| 175 |
| 176 void ControlsPlay() { |
| 177 media_session_->OnControlsResume(); |
| 178 } |
| 179 |
| 180 void ControlsPause() { |
| 181 media_session_->OnControlsPause(); |
| 182 } |
| 183 |
| 184 const MockWebContentsDelegate* mock_web_contents_delegate() { |
| 185 return mock_web_contents_delegate_.get(); |
| 186 } |
| 187 |
| 188 protected: |
| 189 scoped_ptr<MockWebContentsDelegate> mock_web_contents_delegate_; |
| 190 |
| 191 MediaSession* media_session_; |
| 192 |
| 193 WebContentsDelegate* previous_delegate_; |
| 194 |
108 DISALLOW_COPY_AND_ASSIGN(MediaSessionBrowserTest); | 195 DISALLOW_COPY_AND_ASSIGN(MediaSessionBrowserTest); |
109 }; | 196 }; |
110 | 197 |
111 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 198 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
112 PlayersFromSameObserverDoNotStopEachOtherInSameSession) { | 199 PlayersFromSameObserverDoNotStopEachOtherInSameSession) { |
113 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
114 ASSERT_TRUE(media_session); | |
115 DisableNativeBackend(media_session); | |
116 | |
117 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 200 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
118 new MockMediaSessionObserver); | 201 new MockMediaSessionObserver); |
119 | 202 |
120 StartNewPlayer(media_session, media_session_observer.get(), | 203 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
121 MediaSession::Type::Content); | 204 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
122 StartNewPlayer(media_session, media_session_observer.get(), | 205 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
123 MediaSession::Type::Content); | |
124 StartNewPlayer(media_session, media_session_observer.get(), | |
125 MediaSession::Type::Content); | |
126 | 206 |
127 EXPECT_TRUE(media_session_observer->IsPlaying(0)); | 207 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
128 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 208 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
129 EXPECT_TRUE(media_session_observer->IsPlaying(2)); | 209 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
130 | |
131 media_session->RemovePlayers(media_session_observer.get()); | |
132 } | 210 } |
133 | 211 |
134 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 212 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
135 PlayersFromManyObserverDoNotStopEachOtherInSameSession) { | 213 PlayersFromManyObserverDoNotStopEachOtherInSameSession) { |
136 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
137 ASSERT_TRUE(media_session); | |
138 DisableNativeBackend(media_session); | |
139 | |
140 scoped_ptr<MockMediaSessionObserver> media_session_observer_1( | 214 scoped_ptr<MockMediaSessionObserver> media_session_observer_1( |
141 new MockMediaSessionObserver); | 215 new MockMediaSessionObserver); |
142 scoped_ptr<MockMediaSessionObserver> media_session_observer_2( | 216 scoped_ptr<MockMediaSessionObserver> media_session_observer_2( |
143 new MockMediaSessionObserver); | 217 new MockMediaSessionObserver); |
144 scoped_ptr<MockMediaSessionObserver> media_session_observer_3( | 218 scoped_ptr<MockMediaSessionObserver> media_session_observer_3( |
145 new MockMediaSessionObserver); | 219 new MockMediaSessionObserver); |
146 | 220 |
147 StartNewPlayer(media_session, media_session_observer_1.get(), | 221 StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content); |
148 MediaSession::Type::Content); | 222 |
149 StartNewPlayer(media_session, media_session_observer_2.get(), | 223 StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content); |
150 MediaSession::Type::Content); | 224 StartNewPlayer(media_session_observer_3.get(), MediaSession::Type::Content); |
151 StartNewPlayer(media_session, media_session_observer_3.get(), | |
152 MediaSession::Type::Content); | |
153 | 225 |
154 EXPECT_TRUE(media_session_observer_1->IsPlaying(0)); | 226 EXPECT_TRUE(media_session_observer_1->IsPlaying(0)); |
155 EXPECT_TRUE(media_session_observer_2->IsPlaying(0)); | 227 EXPECT_TRUE(media_session_observer_2->IsPlaying(0)); |
156 EXPECT_TRUE(media_session_observer_3->IsPlaying(0)); | 228 EXPECT_TRUE(media_session_observer_3->IsPlaying(0)); |
157 | |
158 media_session->RemovePlayers(media_session_observer_1.get()); | |
159 media_session->RemovePlayers(media_session_observer_2.get()); | |
160 media_session->RemovePlayers(media_session_observer_3.get()); | |
161 } | 229 } |
162 | 230 |
163 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 231 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
164 SuspendedMediaSessionStopsPlayers) { | 232 SuspendedMediaSessionStopsPlayers) { |
165 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
166 ASSERT_TRUE(media_session); | |
167 DisableNativeBackend(media_session); | |
168 | |
169 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 233 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
170 new MockMediaSessionObserver); | 234 new MockMediaSessionObserver); |
171 | 235 |
172 StartNewPlayer(media_session, media_session_observer.get(), | 236 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
173 MediaSession::Type::Content); | 237 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
174 StartNewPlayer(media_session, media_session_observer.get(), | 238 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
175 MediaSession::Type::Content); | |
176 StartNewPlayer(media_session, media_session_observer.get(), | |
177 MediaSession::Type::Content); | |
178 | 239 |
179 SuspendSession(media_session); | 240 SuspendSession(true); |
180 | 241 |
181 EXPECT_FALSE(media_session_observer->IsPlaying(0)); | 242 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
182 EXPECT_FALSE(media_session_observer->IsPlaying(1)); | 243 EXPECT_FALSE(media_session_observer->IsPlaying(1)); |
183 EXPECT_FALSE(media_session_observer->IsPlaying(2)); | 244 EXPECT_FALSE(media_session_observer->IsPlaying(2)); |
184 | |
185 media_session->RemovePlayers(media_session_observer.get()); | |
186 } | 245 } |
187 | 246 |
188 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 247 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
189 ResumedMediaSessionRestartsPlayers) { | 248 ResumedMediaSessionRestartsPlayers) { |
190 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
191 ASSERT_TRUE(media_session); | |
192 DisableNativeBackend(media_session); | |
193 | |
194 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 249 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
195 new MockMediaSessionObserver); | 250 new MockMediaSessionObserver); |
196 | 251 |
197 StartNewPlayer(media_session, media_session_observer.get(), | 252 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
198 MediaSession::Type::Content); | 253 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
199 StartNewPlayer(media_session, media_session_observer.get(), | 254 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
200 MediaSession::Type::Content); | |
201 StartNewPlayer(media_session, media_session_observer.get(), | |
202 MediaSession::Type::Content); | |
203 | 255 |
204 SuspendSession(media_session); | 256 SuspendSession(true); |
205 ResumeSession(media_session); | 257 ResumeSession(); |
206 | 258 |
207 EXPECT_TRUE(media_session_observer->IsPlaying(0)); | 259 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
208 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 260 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
209 EXPECT_TRUE(media_session_observer->IsPlaying(2)); | 261 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
210 | |
211 media_session->RemovePlayers(media_session_observer.get()); | |
212 } | 262 } |
213 | 263 |
214 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 264 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
215 StartedPlayerOnSuspendedSessionPlaysAlone) { | 265 StartedPlayerOnSuspendedSessionPlaysAlone) { |
216 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
217 ASSERT_TRUE(media_session); | |
218 DisableNativeBackend(media_session); | |
219 | |
220 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 266 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
221 new MockMediaSessionObserver); | 267 new MockMediaSessionObserver); |
222 | 268 |
223 StartNewPlayer(media_session, media_session_observer.get(), | 269 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
224 MediaSession::Type::Content); | |
225 | 270 |
226 EXPECT_TRUE(media_session_observer->IsPlaying(0)); | 271 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
227 | 272 |
228 SuspendSession(media_session); | 273 SuspendSession(true); |
229 | 274 |
230 EXPECT_FALSE(media_session_observer->IsPlaying(0)); | 275 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
231 | 276 |
232 StartNewPlayer(media_session, media_session_observer.get(), | 277 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
233 MediaSession::Type::Content); | |
234 | 278 |
235 EXPECT_FALSE(media_session_observer->IsPlaying(0)); | 279 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
236 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 280 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
237 | 281 |
238 StartNewPlayer(media_session, media_session_observer.get(), | 282 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
239 MediaSession::Type::Content); | |
240 | 283 |
241 EXPECT_FALSE(media_session_observer->IsPlaying(0)); | 284 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
242 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 285 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
243 EXPECT_TRUE(media_session_observer->IsPlaying(2)); | 286 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
244 | |
245 media_session->RemovePlayers(media_session_observer.get()); | |
246 } | 287 } |
247 | 288 |
248 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, AudioFocusInitialState) { | 289 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, AudioFocusInitialState) { |
249 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | 290 EXPECT_FALSE(HasAudioFocus()); |
250 ASSERT_TRUE(media_session); | |
251 DisableNativeBackend(media_session); | |
252 | |
253 EXPECT_FALSE(HasAudioFocus(media_session)); | |
254 } | 291 } |
255 | 292 |
256 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, StartPlayerGivesFocus) { | 293 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, StartPlayerGivesFocus) { |
257 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
258 ASSERT_TRUE(media_session); | |
259 DisableNativeBackend(media_session); | |
260 | |
261 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 294 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
262 new MockMediaSessionObserver); | 295 new MockMediaSessionObserver); |
263 | 296 |
264 StartNewPlayer(media_session, media_session_observer.get(), | 297 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
265 MediaSession::Type::Content); | |
266 | 298 |
267 EXPECT_TRUE(HasAudioFocus(media_session)); | 299 EXPECT_TRUE(HasAudioFocus()); |
268 | |
269 media_session->RemovePlayers(media_session_observer.get()); | |
270 } | 300 } |
271 | 301 |
272 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, SuspendGivesAwayAudioFocus) { | 302 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, SuspendGivesAwayAudioFocus) { |
273 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
274 ASSERT_TRUE(media_session); | |
275 DisableNativeBackend(media_session); | |
276 | |
277 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 303 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
278 new MockMediaSessionObserver); | 304 new MockMediaSessionObserver); |
279 | 305 |
280 StartNewPlayer(media_session, media_session_observer.get(), | 306 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
281 MediaSession::Type::Content); | |
282 | 307 |
283 SuspendSession(media_session); | 308 SuspendSession(true); |
284 | 309 |
285 EXPECT_FALSE(HasAudioFocus(media_session)); | 310 EXPECT_FALSE(HasAudioFocus()); |
286 | |
287 media_session->RemovePlayers(media_session_observer.get()); | |
288 } | 311 } |
289 | 312 |
290 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumeGivesBackAudioFocus) { | 313 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumeGivesBackAudioFocus) { |
291 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
292 ASSERT_TRUE(media_session); | |
293 DisableNativeBackend(media_session); | |
294 | |
295 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 314 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
296 new MockMediaSessionObserver); | 315 new MockMediaSessionObserver); |
297 | 316 |
298 StartNewPlayer(media_session, media_session_observer.get(), | 317 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
299 MediaSession::Type::Content); | |
300 | 318 |
301 SuspendSession(media_session); | 319 SuspendSession(true); |
302 ResumeSession(media_session); | 320 ResumeSession(); |
303 | 321 |
304 EXPECT_TRUE(HasAudioFocus(media_session)); | 322 EXPECT_TRUE(HasAudioFocus()); |
305 | |
306 media_session->RemovePlayers(media_session_observer.get()); | |
307 } | 323 } |
308 | 324 |
309 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 325 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
310 RemovingLastPlayerDropsAudioFocus_1) { | 326 RemovingLastPlayerDropsAudioFocus) { |
311 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
312 ASSERT_TRUE(media_session); | |
313 DisableNativeBackend(media_session); | |
314 | |
315 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 327 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
316 new MockMediaSessionObserver); | 328 new MockMediaSessionObserver); |
317 | 329 |
318 StartNewPlayer(media_session, media_session_observer.get(), | 330 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
319 MediaSession::Type::Content); | 331 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
320 StartNewPlayer(media_session, media_session_observer.get(), | 332 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
321 MediaSession::Type::Content); | |
322 StartNewPlayer(media_session, media_session_observer.get(), | |
323 MediaSession::Type::Content); | |
324 | 333 |
325 media_session->RemovePlayer(media_session_observer.get(), 0); | 334 RemovePlayer(media_session_observer.get(), 0); |
326 EXPECT_TRUE(HasAudioFocus(media_session)); | 335 EXPECT_TRUE(HasAudioFocus()); |
327 media_session->RemovePlayer(media_session_observer.get(), 1); | 336 RemovePlayer(media_session_observer.get(), 1); |
328 EXPECT_TRUE(HasAudioFocus(media_session)); | 337 EXPECT_TRUE(HasAudioFocus()); |
329 media_session->RemovePlayer(media_session_observer.get(), 2); | 338 RemovePlayer(media_session_observer.get(), 2); |
330 EXPECT_FALSE(HasAudioFocus(media_session)); | 339 EXPECT_FALSE(HasAudioFocus()); |
331 } | 340 } |
332 | 341 |
333 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 342 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
334 RemovingLastPlayerDropsAudioFocus_2) { | 343 RemovingLastPlayerFromManyObserversDropsAudioFocus) { |
335 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
336 ASSERT_TRUE(media_session); | |
337 DisableNativeBackend(media_session); | |
338 | |
339 scoped_ptr<MockMediaSessionObserver> media_session_observer_1( | 344 scoped_ptr<MockMediaSessionObserver> media_session_observer_1( |
340 new MockMediaSessionObserver); | 345 new MockMediaSessionObserver); |
341 scoped_ptr<MockMediaSessionObserver> media_session_observer_2( | 346 scoped_ptr<MockMediaSessionObserver> media_session_observer_2( |
342 new MockMediaSessionObserver); | 347 new MockMediaSessionObserver); |
343 scoped_ptr<MockMediaSessionObserver> media_session_observer_3( | 348 scoped_ptr<MockMediaSessionObserver> media_session_observer_3( |
344 new MockMediaSessionObserver); | 349 new MockMediaSessionObserver); |
345 | 350 |
346 StartNewPlayer(media_session, media_session_observer_1.get(), | 351 StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content); |
347 MediaSession::Type::Content); | 352 StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content); |
348 StartNewPlayer(media_session, media_session_observer_2.get(), | 353 StartNewPlayer(media_session_observer_3.get(), MediaSession::Type::Content); |
349 MediaSession::Type::Content); | 354 |
350 StartNewPlayer(media_session, media_session_observer_3.get(), | 355 RemovePlayer(media_session_observer_1.get(), 0); |
351 MediaSession::Type::Content); | 356 EXPECT_TRUE(HasAudioFocus()); |
352 | 357 RemovePlayer(media_session_observer_2.get(), 0); |
353 media_session->RemovePlayer(media_session_observer_1.get(), 0); | 358 EXPECT_TRUE(HasAudioFocus()); |
354 EXPECT_TRUE(HasAudioFocus(media_session)); | 359 RemovePlayer(media_session_observer_3.get(), 0); |
355 media_session->RemovePlayer(media_session_observer_2.get(), 0); | 360 EXPECT_FALSE(HasAudioFocus()); |
356 EXPECT_TRUE(HasAudioFocus(media_session)); | 361 } |
357 media_session->RemovePlayer(media_session_observer_3.get(), 0); | 362 |
358 EXPECT_FALSE(HasAudioFocus(media_session)); | 363 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
359 } | 364 RemovingAllPlayersFromObserversDropsAudioFocus) { |
360 | |
361 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | |
362 RemovingLastPlayerDropsAudioFocus_3) { | |
363 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
364 ASSERT_TRUE(media_session); | |
365 DisableNativeBackend(media_session); | |
366 | |
367 scoped_ptr<MockMediaSessionObserver> media_session_observer_1( | 365 scoped_ptr<MockMediaSessionObserver> media_session_observer_1( |
368 new MockMediaSessionObserver); | 366 new MockMediaSessionObserver); |
369 scoped_ptr<MockMediaSessionObserver> media_session_observer_2( | 367 scoped_ptr<MockMediaSessionObserver> media_session_observer_2( |
370 new MockMediaSessionObserver); | 368 new MockMediaSessionObserver); |
371 | 369 |
372 StartNewPlayer(media_session, media_session_observer_1.get(), | 370 StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content); |
373 MediaSession::Type::Content); | 371 StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content); |
374 StartNewPlayer(media_session, media_session_observer_1.get(), | 372 StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content); |
375 MediaSession::Type::Content); | 373 StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content); |
376 StartNewPlayer(media_session, media_session_observer_2.get(), | 374 |
377 MediaSession::Type::Content); | 375 RemovePlayers(media_session_observer_1.get()); |
378 StartNewPlayer(media_session, media_session_observer_2.get(), | 376 EXPECT_TRUE(HasAudioFocus()); |
379 MediaSession::Type::Content); | 377 RemovePlayers(media_session_observer_2.get()); |
380 | 378 EXPECT_FALSE(HasAudioFocus()); |
381 media_session->RemovePlayers(media_session_observer_1.get()); | |
382 EXPECT_TRUE(HasAudioFocus(media_session)); | |
383 media_session->RemovePlayers(media_session_observer_2.get()); | |
384 EXPECT_FALSE(HasAudioFocus(media_session)); | |
385 } | 379 } |
386 | 380 |
387 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumePlayGivesAudioFocus) { | 381 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumePlayGivesAudioFocus) { |
388 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | 382 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
389 ASSERT_TRUE(media_session); | 383 new MockMediaSessionObserver); |
390 DisableNativeBackend(media_session); | 384 |
391 | 385 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
392 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 386 |
393 new MockMediaSessionObserver); | 387 RemovePlayer(media_session_observer.get(), 0); |
394 | 388 EXPECT_FALSE(HasAudioFocus()); |
395 StartNewPlayer(media_session, media_session_observer.get(), | 389 |
396 MediaSession::Type::Content); | 390 EXPECT_TRUE(AddPlayer( |
397 | 391 media_session_observer.get(), 0, MediaSession::Type::Content)); |
398 media_session->RemovePlayer(media_session_observer.get(), 0); | 392 EXPECT_TRUE(HasAudioFocus()); |
399 EXPECT_FALSE(HasAudioFocus(media_session)); | 393 } |
400 | 394 |
401 EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 0, | 395 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
402 MediaSession::Type::Content)); | 396 ResumeSuspendAreSentOnlyOncePerPlayers) { |
403 EXPECT_TRUE(HasAudioFocus(media_session)); | 397 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
404 | 398 new MockMediaSessionObserver); |
405 media_session->RemovePlayers(media_session_observer.get()); | 399 |
406 } | 400 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
407 | 401 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
408 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 402 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
409 ResumeSuspendAreSentOnlyOncePerPlayers_1) { | |
410 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
411 ASSERT_TRUE(media_session); | |
412 DisableNativeBackend(media_session); | |
413 | |
414 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
415 new MockMediaSessionObserver); | |
416 | |
417 StartNewPlayer(media_session, media_session_observer.get(), | |
418 MediaSession::Type::Content); | |
419 StartNewPlayer(media_session, media_session_observer.get(), | |
420 MediaSession::Type::Content); | |
421 StartNewPlayer(media_session, media_session_observer.get(), | |
422 MediaSession::Type::Content); | |
423 | 403 |
424 EXPECT_EQ(0, media_session_observer->received_suspend_calls()); | 404 EXPECT_EQ(0, media_session_observer->received_suspend_calls()); |
425 EXPECT_EQ(0, media_session_observer->received_resume_calls()); | 405 EXPECT_EQ(0, media_session_observer->received_resume_calls()); |
426 | 406 |
427 SuspendSession(media_session); | 407 SuspendSession(true); |
428 EXPECT_EQ(3, media_session_observer->received_suspend_calls()); | 408 EXPECT_EQ(3, media_session_observer->received_suspend_calls()); |
429 | 409 |
430 ResumeSession(media_session); | 410 ResumeSession(); |
431 EXPECT_EQ(3, media_session_observer->received_resume_calls()); | 411 EXPECT_EQ(3, media_session_observer->received_resume_calls()); |
432 | 412 } |
433 media_session->RemovePlayers(media_session_observer.get()); | 413 |
434 } | 414 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
435 | 415 ResumeSuspendAreSentOnlyOncePerPlayersAddedTwice) { |
436 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 416 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
437 ResumeSuspendAreSentOnlyOncePerPlayers_2) { | 417 new MockMediaSessionObserver); |
438 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | 418 |
439 ASSERT_TRUE(media_session); | 419 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
440 DisableNativeBackend(media_session); | 420 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
441 | 421 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
442 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
443 new MockMediaSessionObserver); | |
444 | |
445 StartNewPlayer(media_session, media_session_observer.get(), | |
446 MediaSession::Type::Content); | |
447 StartNewPlayer(media_session, media_session_observer.get(), | |
448 MediaSession::Type::Content); | |
449 StartNewPlayer(media_session, media_session_observer.get(), | |
450 MediaSession::Type::Content); | |
451 | 422 |
452 // Adding the three players above again. | 423 // Adding the three players above again. |
453 EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 0, | 424 EXPECT_TRUE(AddPlayer( |
454 MediaSession::Type::Content)); | 425 media_session_observer.get(), 0, MediaSession::Type::Content)); |
455 EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 1, | 426 EXPECT_TRUE(AddPlayer( |
456 MediaSession::Type::Content)); | 427 media_session_observer.get(), 1, MediaSession::Type::Content)); |
457 EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 2, | 428 EXPECT_TRUE(AddPlayer( |
458 MediaSession::Type::Content)); | 429 media_session_observer.get(), 2, MediaSession::Type::Content)); |
459 | 430 |
460 EXPECT_EQ(0, media_session_observer->received_suspend_calls()); | 431 EXPECT_EQ(0, media_session_observer->received_suspend_calls()); |
461 EXPECT_EQ(0, media_session_observer->received_resume_calls()); | 432 EXPECT_EQ(0, media_session_observer->received_resume_calls()); |
462 | 433 |
463 SuspendSession(media_session); | 434 SuspendSession(true); |
464 EXPECT_EQ(3, media_session_observer->received_suspend_calls()); | 435 EXPECT_EQ(3, media_session_observer->received_suspend_calls()); |
465 | 436 |
466 ResumeSession(media_session); | 437 ResumeSession(); |
467 EXPECT_EQ(3, media_session_observer->received_resume_calls()); | 438 EXPECT_EQ(3, media_session_observer->received_resume_calls()); |
468 | |
469 media_session->RemovePlayers(media_session_observer.get()); | |
470 } | 439 } |
471 | 440 |
472 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 441 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
473 RemovingTheSamePlayerTwiceIsANoop) { | 442 RemovingTheSamePlayerTwiceIsANoop) { |
474 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | 443 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
475 ASSERT_TRUE(media_session); | 444 new MockMediaSessionObserver); |
476 DisableNativeBackend(media_session); | 445 |
477 | 446 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
478 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 447 |
479 new MockMediaSessionObserver); | 448 RemovePlayer(media_session_observer.get(), 0); |
480 | 449 RemovePlayer(media_session_observer.get(), 0); |
481 StartNewPlayer(media_session, media_session_observer.get(), | |
482 MediaSession::Type::Content); | |
483 | |
484 media_session->RemovePlayer(media_session_observer.get(), 0); | |
485 media_session->RemovePlayer(media_session_observer.get(), 0); | |
486 | |
487 media_session->RemovePlayers(media_session_observer.get()); | |
488 } | 450 } |
489 | 451 |
490 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, MediaSessionType) { | 452 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, MediaSessionType) { |
491 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
492 ASSERT_TRUE(media_session); | |
493 DisableNativeBackend(media_session); | |
494 | |
495 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 453 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
496 new MockMediaSessionObserver); | 454 new MockMediaSessionObserver); |
497 | 455 |
498 // Starting a player with a given type should set the session to that type. | 456 // Starting a player with a given type should set the session to that type. |
499 StartNewPlayer(media_session, media_session_observer.get(), | 457 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); |
500 MediaSession::Type::Transient); | 458 EXPECT_EQ(MediaSession::Type::Transient, GetSessionType()); |
501 EXPECT_EQ(MediaSession::Type::Transient, GetSessionType(media_session)); | |
502 | 459 |
503 // Adding a player of the same type should have no effect on the type. | 460 // Adding a player of the same type should have no effect on the type. |
504 StartNewPlayer(media_session, media_session_observer.get(), | 461 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); |
505 MediaSession::Type::Transient); | 462 EXPECT_EQ(MediaSession::Type::Transient, GetSessionType()); |
506 EXPECT_EQ(MediaSession::Type::Transient, GetSessionType(media_session)); | |
507 | 463 |
508 // Adding a player of Content type should override the current type. | 464 // Adding a player of Content type should override the current type. |
509 StartNewPlayer(media_session, media_session_observer.get(), | 465 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
510 MediaSession::Type::Content); | 466 EXPECT_EQ(MediaSession::Type::Content, GetSessionType()); |
511 EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session)); | |
512 | 467 |
513 // Adding a player of the Transient type should have no effect on the type. | 468 // Adding a player of the Transient type should have no effect on the type. |
514 StartNewPlayer(media_session, media_session_observer.get(), | 469 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); |
515 MediaSession::Type::Transient); | 470 EXPECT_EQ(MediaSession::Type::Content, GetSessionType()); |
516 EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session)); | |
517 | 471 |
518 EXPECT_TRUE(media_session_observer->IsPlaying(0)); | 472 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
519 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 473 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
520 EXPECT_TRUE(media_session_observer->IsPlaying(2)); | 474 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
521 EXPECT_TRUE(media_session_observer->IsPlaying(3)); | 475 EXPECT_TRUE(media_session_observer->IsPlaying(3)); |
522 | 476 |
523 SuspendSession(media_session); | 477 SuspendSession(true); |
524 | 478 |
525 EXPECT_FALSE(media_session_observer->IsPlaying(0)); | 479 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
526 EXPECT_FALSE(media_session_observer->IsPlaying(1)); | 480 EXPECT_FALSE(media_session_observer->IsPlaying(1)); |
527 EXPECT_FALSE(media_session_observer->IsPlaying(2)); | 481 EXPECT_FALSE(media_session_observer->IsPlaying(2)); |
528 EXPECT_FALSE(media_session_observer->IsPlaying(3)); | 482 EXPECT_FALSE(media_session_observer->IsPlaying(3)); |
529 | 483 |
530 EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session)); | 484 EXPECT_EQ(MediaSession::Type::Content, GetSessionType()); |
531 | 485 |
532 ResumeSession(media_session); | 486 ResumeSession(); |
533 | 487 |
534 EXPECT_TRUE(media_session_observer->IsPlaying(0)); | 488 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
535 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 489 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
536 EXPECT_TRUE(media_session_observer->IsPlaying(2)); | 490 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
537 EXPECT_TRUE(media_session_observer->IsPlaying(3)); | 491 EXPECT_TRUE(media_session_observer->IsPlaying(3)); |
538 | 492 |
539 EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session)); | 493 EXPECT_EQ(MediaSession::Type::Content, GetSessionType()); |
540 | 494 } |
541 media_session->RemovePlayers(media_session_observer.get()); | 495 |
542 } | 496 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsShowForContent) { |
543 | 497 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
544 } // namespace content | 498 new MockMediaSessionObserver); |
| 499 |
| 500 // Starting a player with a content type should show the media controls. |
| 501 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 502 |
| 503 EXPECT_EQ(1, mock_web_contents_delegate()->update_counter()); |
| 504 EXPECT_TRUE(IsControllable()); |
| 505 EXPECT_FALSE(IsPaused()); |
| 506 } |
| 507 |
| 508 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsNoShowForTransient) { |
| 509 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 510 new MockMediaSessionObserver); |
| 511 |
| 512 // Starting a player with a transient type should not show the media controls. |
| 513 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); |
| 514 |
| 515 EXPECT_EQ(1, mock_web_contents_delegate()->update_counter()); |
| 516 EXPECT_FALSE(IsControllable()); |
| 517 EXPECT_FALSE(IsPaused()); |
| 518 } |
| 519 |
| 520 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsHideWhenStopped) { |
| 521 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 522 new MockMediaSessionObserver); |
| 523 |
| 524 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 525 |
| 526 RemovePlayers(media_session_observer.get()); |
| 527 |
| 528 EXPECT_EQ(2, mock_web_contents_delegate()->update_counter()); |
| 529 EXPECT_FALSE(IsControllable()); |
| 530 EXPECT_TRUE(IsPaused()); |
| 531 } |
| 532 |
| 533 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsShownAcceptTransient) { |
| 534 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 535 new MockMediaSessionObserver); |
| 536 |
| 537 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 538 |
| 539 // Transient player join the session without affecting the controls. |
| 540 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); |
| 541 |
| 542 EXPECT_EQ(1, mock_web_contents_delegate()->update_counter()); |
| 543 EXPECT_TRUE(IsControllable()); |
| 544 EXPECT_FALSE(IsPaused()); |
| 545 } |
| 546 |
| 547 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 548 ControlsShownAfterContentAdded) { |
| 549 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 550 new MockMediaSessionObserver); |
| 551 |
| 552 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); |
| 553 |
| 554 // The controls are shown when the content player is added. |
| 555 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 556 |
| 557 EXPECT_EQ(2, mock_web_contents_delegate()->update_counter()); |
| 558 EXPECT_TRUE(IsControllable()); |
| 559 EXPECT_FALSE(IsPaused()); |
| 560 } |
| 561 |
| 562 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 563 ControlsStayIfOnlyOnePlayerHasBeenPaused) { |
| 564 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 565 new MockMediaSessionObserver); |
| 566 |
| 567 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 568 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); |
| 569 |
| 570 // Removing only content player doesn't hide the controls since the session |
| 571 // is still active. |
| 572 RemovePlayer(media_session_observer.get(), 0); |
| 573 |
| 574 EXPECT_EQ(1, mock_web_contents_delegate()->update_counter()); |
| 575 EXPECT_TRUE(IsControllable()); |
| 576 EXPECT_FALSE(IsPaused()); |
| 577 } |
| 578 |
| 579 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 580 ControlsHideWhenTheLastPlayerIsStopped) { |
| 581 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 582 new MockMediaSessionObserver); |
| 583 |
| 584 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 585 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 586 |
| 587 RemovePlayer(media_session_observer.get(), 0); |
| 588 |
| 589 EXPECT_EQ(1, mock_web_contents_delegate()->update_counter()); |
| 590 EXPECT_TRUE(IsControllable()); |
| 591 EXPECT_FALSE(IsPaused()); |
| 592 |
| 593 RemovePlayer(media_session_observer.get(), 1); |
| 594 |
| 595 EXPECT_EQ(2, mock_web_contents_delegate()->update_counter()); |
| 596 EXPECT_FALSE(IsControllable()); |
| 597 EXPECT_TRUE(IsPaused()); |
| 598 } |
| 599 |
| 600 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 601 ControlsHideWhenAllThePlayersAreRemoved) { |
| 602 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 603 new MockMediaSessionObserver); |
| 604 |
| 605 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 606 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 607 |
| 608 RemovePlayers(media_session_observer.get()); |
| 609 |
| 610 EXPECT_EQ(2, mock_web_contents_delegate()->update_counter()); |
| 611 EXPECT_FALSE(IsControllable()); |
| 612 EXPECT_TRUE(IsPaused()); |
| 613 } |
| 614 |
| 615 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 616 SuspendTemporaryUpdatesControls) { |
| 617 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 618 new MockMediaSessionObserver); |
| 619 |
| 620 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 621 |
| 622 SuspendSession(true); |
| 623 |
| 624 EXPECT_EQ(2, mock_web_contents_delegate()->update_counter()); |
| 625 EXPECT_TRUE(IsControllable()); |
| 626 EXPECT_TRUE(IsPaused()); |
| 627 } |
| 628 |
| 629 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsUpdatedWhenResumed) { |
| 630 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 631 new MockMediaSessionObserver); |
| 632 |
| 633 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 634 SuspendSession(true); |
| 635 ResumeSession(); |
| 636 |
| 637 EXPECT_EQ(3, mock_web_contents_delegate()->update_counter()); |
| 638 EXPECT_TRUE(IsControllable()); |
| 639 EXPECT_FALSE(IsPaused()); |
| 640 } |
| 641 |
| 642 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 643 ControlsHideWhenSessionSuspendedPermanently) { |
| 644 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 645 new MockMediaSessionObserver); |
| 646 |
| 647 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 648 |
| 649 SuspendSession(false); |
| 650 |
| 651 EXPECT_EQ(2, mock_web_contents_delegate()->update_counter()); |
| 652 EXPECT_FALSE(IsControllable()); |
| 653 EXPECT_TRUE(IsPaused()); |
| 654 } |
| 655 |
| 656 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 657 ControlsHideWhenSessionChangesFromContentToTransient) { |
| 658 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 659 new MockMediaSessionObserver); |
| 660 |
| 661 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 662 SuspendSession(true); |
| 663 |
| 664 // This should reset the session and change it to a transient, so |
| 665 // hide the controls. |
| 666 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); |
| 667 |
| 668 EXPECT_EQ(3, mock_web_contents_delegate()->update_counter()); |
| 669 EXPECT_FALSE(IsControllable()); |
| 670 EXPECT_FALSE(IsPaused()); |
| 671 } |
| 672 |
| 673 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 674 ControlsUpdatedWhenNewPlayerResetsSession) { |
| 675 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 676 new MockMediaSessionObserver); |
| 677 |
| 678 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 679 SuspendSession(true); |
| 680 |
| 681 // This should reset the session and update the controls. |
| 682 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 683 |
| 684 EXPECT_EQ(3, mock_web_contents_delegate()->update_counter()); |
| 685 EXPECT_TRUE(IsControllable()); |
| 686 EXPECT_FALSE(IsPaused()); |
| 687 } |
| 688 |
| 689 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 690 ControlsResumedWhenPlayerIsResumed) { |
| 691 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 692 new MockMediaSessionObserver); |
| 693 |
| 694 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 695 SuspendSession(true); |
| 696 |
| 697 // This should resume the session and update the controls. |
| 698 AddPlayer(media_session_observer.get(), 0, MediaSession::Type::Content); |
| 699 |
| 700 EXPECT_EQ(3, mock_web_contents_delegate()->update_counter()); |
| 701 EXPECT_TRUE(IsControllable()); |
| 702 EXPECT_FALSE(IsPaused()); |
| 703 } |
| 704 |
| 705 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 706 ControlsNotUpdatedDueToControlsPlayAction) { |
| 707 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 708 new MockMediaSessionObserver); |
| 709 |
| 710 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 711 ControlsPause(); |
| 712 |
| 713 EXPECT_EQ(1, mock_web_contents_delegate()->update_counter()); |
| 714 EXPECT_TRUE(IsControllable()); |
| 715 EXPECT_TRUE(IsPaused()); |
| 716 } |
| 717 |
| 718 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 719 ControlsNotUpdatedDueToControlsPauseAction) { |
| 720 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 721 new MockMediaSessionObserver); |
| 722 |
| 723 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
| 724 ControlsPause(); |
| 725 ControlsPlay(); |
| 726 |
| 727 EXPECT_EQ(1, mock_web_contents_delegate()->update_counter()); |
| 728 EXPECT_TRUE(IsControllable()); |
| 729 EXPECT_FALSE(IsPaused()); |
| 730 } |
OLD | NEW |