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.h" | 5 #include "content/browser/media/session/media_session.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> |
11 | 11 |
12 #include "base/macros.h" | 12 #include "base/macros.h" |
13 #include "base/metrics/histogram_samples.h" | 13 #include "base/metrics/histogram_samples.h" |
14 #include "base/test/histogram_tester.h" | 14 #include "base/test/histogram_tester.h" |
15 #include "base/test/simple_test_tick_clock.h" | 15 #include "base/test/simple_test_tick_clock.h" |
16 #include "content/browser/media/session/media_session_delegate.h" | 16 #include "content/browser/media/session/media_session_delegate.h" |
17 #include "content/browser/media/session/mock_media_session_observer.h" | 17 #include "content/browser/media/session/mock_media_session_observer.h" |
18 #include "content/public/browser/web_contents.h" | 18 #include "content/public/browser/web_contents.h" |
19 #include "content/public/browser/web_contents_observer.h" | 19 #include "content/public/browser/web_contents_observer.h" |
20 #include "content/public/test/content_browser_test.h" | 20 #include "content/public/test/content_browser_test.h" |
21 #include "content/shell/browser/shell.h" | 21 #include "content/shell/browser/shell.h" |
| 22 #include "media/base/media_content_type.h" |
22 #include "testing/gmock/include/gmock/gmock.h" | 23 #include "testing/gmock/include/gmock/gmock.h" |
23 | 24 |
24 using content::WebContents; | 25 using content::WebContents; |
25 using content::WebContentsObserver; | 26 using content::WebContentsObserver; |
26 using content::MediaSession; | 27 using content::MediaSession; |
27 using content::MediaSessionDelegate; | 28 using content::MediaSessionDelegate; |
28 using content::MediaSessionObserver; | 29 using content::MediaSessionObserver; |
29 using content::MediaSessionUmaHelper; | 30 using content::MediaSessionUmaHelper; |
30 using content::MockMediaSessionObserver; | 31 using content::MockMediaSessionObserver; |
31 | 32 |
32 using ::testing::Expectation; | 33 using ::testing::Expectation; |
33 | 34 |
34 namespace { | 35 namespace { |
35 | 36 |
36 class MockMediaSessionDelegate : public MediaSessionDelegate { | 37 class MockMediaSessionDelegate : public MediaSessionDelegate { |
37 public: | 38 public: |
38 bool RequestAudioFocus(MediaSession::Type) override { | 39 bool RequestAudioFocus(MediaSession::AudioFocusType) override { return true; } |
39 return true; | |
40 } | |
41 | 40 |
42 void AbandonAudioFocus() override { | 41 void AbandonAudioFocus() override { |
43 } | 42 } |
44 }; | 43 }; |
45 | 44 |
46 class MockWebContentsObserver : public WebContentsObserver { | 45 class MockWebContentsObserver : public WebContentsObserver { |
47 public: | 46 public: |
48 MockWebContentsObserver(WebContents* web_contents) | 47 MockWebContentsObserver(WebContents* web_contents) |
49 : WebContentsObserver(web_contents) {} | 48 : WebContentsObserver(web_contents) {} |
50 | 49 |
(...skipping 22 matching lines...) Expand all Loading... |
73 void TearDownOnMainThread() override { | 72 void TearDownOnMainThread() override { |
74 mock_web_contents_observer_.reset(); | 73 mock_web_contents_observer_.reset(); |
75 | 74 |
76 media_session_->RemoveAllPlayersForTest(); | 75 media_session_->RemoveAllPlayersForTest(); |
77 media_session_ = nullptr; | 76 media_session_ = nullptr; |
78 | 77 |
79 ContentBrowserTest::TearDownOnMainThread(); | 78 ContentBrowserTest::TearDownOnMainThread(); |
80 } | 79 } |
81 | 80 |
82 void StartNewPlayer(MockMediaSessionObserver* media_session_observer, | 81 void StartNewPlayer(MockMediaSessionObserver* media_session_observer, |
83 MediaSession::Type type) { | 82 media::MediaContentType type) { |
84 bool result = AddPlayer( | 83 bool result = AddPlayer( |
85 media_session_observer, | 84 media_session_observer, |
86 media_session_observer->StartNewPlayer(), | 85 media_session_observer->StartNewPlayer(), |
87 type); | 86 type); |
88 EXPECT_TRUE(result); | 87 EXPECT_TRUE(result); |
89 } | 88 } |
90 | 89 |
91 bool AddPlayer(MockMediaSessionObserver* media_session_observer, | 90 bool AddPlayer(MockMediaSessionObserver* media_session_observer, |
92 int player_id, | 91 int player_id, |
93 MediaSession::Type type) { | 92 media::MediaContentType type) { |
94 return media_session_->AddPlayer(media_session_observer, player_id, type); | 93 return media_session_->AddPlayer(media_session_observer, player_id, type); |
95 } | 94 } |
96 | 95 |
97 void RemovePlayer(MockMediaSessionObserver* media_session_observer, | 96 void RemovePlayer(MockMediaSessionObserver* media_session_observer, |
98 int player_id) { | 97 int player_id) { |
99 media_session_->RemovePlayer(media_session_observer, player_id); | 98 media_session_->RemovePlayer(media_session_observer, player_id); |
100 } | 99 } |
101 | 100 |
102 void RemovePlayers(MockMediaSessionObserver* media_session_observer) { | 101 void RemovePlayers(MockMediaSessionObserver* media_session_observer) { |
103 media_session_->RemovePlayers(media_session_observer); | 102 media_session_->RemovePlayers(media_session_observer); |
104 } | 103 } |
105 | 104 |
106 void OnPlayerPaused(MockMediaSessionObserver* media_session_observer, | 105 void OnPlayerPaused(MockMediaSessionObserver* media_session_observer, |
107 int player_id) { | 106 int player_id) { |
108 media_session_->OnPlayerPaused(media_session_observer, player_id); | 107 media_session_->OnPlayerPaused(media_session_observer, player_id); |
109 } | 108 } |
110 | 109 |
111 bool HasAudioFocus() { return media_session_->IsActiveForTest(); } | 110 bool HasAudioFocus() { return media_session_->IsActiveForTest(); } |
112 | 111 |
113 MediaSession::Type GetSessionType() { | 112 MediaSession::AudioFocusType GetSessionType() { |
114 return media_session_->audio_focus_type_for_test(); | 113 return media_session_->audio_focus_type_for_test(); |
115 } | 114 } |
116 | 115 |
117 bool IsControllable() { return media_session_->IsControllable(); } | 116 bool IsControllable() { return media_session_->IsControllable(); } |
118 | 117 |
119 bool IsSuspended() { return media_session_->IsSuspended(); } | 118 bool IsSuspended() { return media_session_->IsSuspended(); } |
120 | 119 |
121 void UIResume() { | 120 void UIResume() { |
122 media_session_->Resume(MediaSession::SuspendType::UI); | 121 media_session_->Resume(MediaSession::SuspendType::UI); |
123 } | 122 } |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
158 std::unique_ptr<MockWebContentsObserver> mock_web_contents_observer_; | 157 std::unique_ptr<MockWebContentsObserver> mock_web_contents_observer_; |
159 | 158 |
160 DISALLOW_COPY_AND_ASSIGN(MediaSessionBrowserTest); | 159 DISALLOW_COPY_AND_ASSIGN(MediaSessionBrowserTest); |
161 }; | 160 }; |
162 | 161 |
163 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 162 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
164 PlayersFromSameObserverDoNotStopEachOtherInSameSession) { | 163 PlayersFromSameObserverDoNotStopEachOtherInSameSession) { |
165 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 164 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
166 new MockMediaSessionObserver); | 165 new MockMediaSessionObserver); |
167 | 166 |
168 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 167 StartNewPlayer(media_session_observer.get(), |
169 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 168 media::MediaContentType::Content); |
170 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 169 StartNewPlayer(media_session_observer.get(), |
| 170 media::MediaContentType::Content); |
| 171 StartNewPlayer(media_session_observer.get(), |
| 172 media::MediaContentType::Content); |
171 | 173 |
172 EXPECT_TRUE(media_session_observer->IsPlaying(0)); | 174 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
173 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 175 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
174 EXPECT_TRUE(media_session_observer->IsPlaying(2)); | 176 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
175 } | 177 } |
176 | 178 |
177 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 179 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
178 PlayersFromManyObserverDoNotStopEachOtherInSameSession) { | 180 PlayersFromManyObserverDoNotStopEachOtherInSameSession) { |
179 std::unique_ptr<MockMediaSessionObserver> media_session_observer_1( | 181 std::unique_ptr<MockMediaSessionObserver> media_session_observer_1( |
180 new MockMediaSessionObserver); | 182 new MockMediaSessionObserver); |
181 std::unique_ptr<MockMediaSessionObserver> media_session_observer_2( | 183 std::unique_ptr<MockMediaSessionObserver> media_session_observer_2( |
182 new MockMediaSessionObserver); | 184 new MockMediaSessionObserver); |
183 std::unique_ptr<MockMediaSessionObserver> media_session_observer_3( | 185 std::unique_ptr<MockMediaSessionObserver> media_session_observer_3( |
184 new MockMediaSessionObserver); | 186 new MockMediaSessionObserver); |
185 | 187 |
186 StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content); | 188 StartNewPlayer(media_session_observer_1.get(), |
187 StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content); | 189 media::MediaContentType::Content); |
188 StartNewPlayer(media_session_observer_3.get(), MediaSession::Type::Content); | 190 StartNewPlayer(media_session_observer_2.get(), |
| 191 media::MediaContentType::Content); |
| 192 StartNewPlayer(media_session_observer_3.get(), |
| 193 media::MediaContentType::Content); |
189 | 194 |
190 EXPECT_TRUE(media_session_observer_1->IsPlaying(0)); | 195 EXPECT_TRUE(media_session_observer_1->IsPlaying(0)); |
191 EXPECT_TRUE(media_session_observer_2->IsPlaying(0)); | 196 EXPECT_TRUE(media_session_observer_2->IsPlaying(0)); |
192 EXPECT_TRUE(media_session_observer_3->IsPlaying(0)); | 197 EXPECT_TRUE(media_session_observer_3->IsPlaying(0)); |
193 } | 198 } |
194 | 199 |
195 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 200 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
196 SuspendedMediaSessionStopsPlayers) { | 201 SuspendedMediaSessionStopsPlayers) { |
197 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 202 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
198 new MockMediaSessionObserver); | 203 new MockMediaSessionObserver); |
199 | 204 |
200 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 205 StartNewPlayer(media_session_observer.get(), |
201 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 206 media::MediaContentType::Content); |
202 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 207 StartNewPlayer(media_session_observer.get(), |
| 208 media::MediaContentType::Content); |
| 209 StartNewPlayer(media_session_observer.get(), |
| 210 media::MediaContentType::Content); |
203 | 211 |
204 SystemSuspend(true); | 212 SystemSuspend(true); |
205 | 213 |
206 EXPECT_FALSE(media_session_observer->IsPlaying(0)); | 214 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
207 EXPECT_FALSE(media_session_observer->IsPlaying(1)); | 215 EXPECT_FALSE(media_session_observer->IsPlaying(1)); |
208 EXPECT_FALSE(media_session_observer->IsPlaying(2)); | 216 EXPECT_FALSE(media_session_observer->IsPlaying(2)); |
209 } | 217 } |
210 | 218 |
211 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 219 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
212 ResumedMediaSessionRestartsPlayers) { | 220 ResumedMediaSessionRestartsPlayers) { |
213 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 221 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
214 new MockMediaSessionObserver); | 222 new MockMediaSessionObserver); |
215 | 223 |
216 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 224 StartNewPlayer(media_session_observer.get(), |
217 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 225 media::MediaContentType::Content); |
218 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 226 StartNewPlayer(media_session_observer.get(), |
| 227 media::MediaContentType::Content); |
| 228 StartNewPlayer(media_session_observer.get(), |
| 229 media::MediaContentType::Content); |
219 | 230 |
220 SystemSuspend(true); | 231 SystemSuspend(true); |
221 SystemResume(); | 232 SystemResume(); |
222 | 233 |
223 EXPECT_TRUE(media_session_observer->IsPlaying(0)); | 234 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
224 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 235 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
225 EXPECT_TRUE(media_session_observer->IsPlaying(2)); | 236 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
226 } | 237 } |
227 | 238 |
228 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 239 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
229 StartedPlayerOnSuspendedSessionPlaysAlone) { | 240 StartedPlayerOnSuspendedSessionPlaysAlone) { |
230 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 241 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
231 new MockMediaSessionObserver); | 242 new MockMediaSessionObserver); |
232 | 243 |
233 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 244 StartNewPlayer(media_session_observer.get(), |
| 245 media::MediaContentType::Content); |
234 | 246 |
235 EXPECT_TRUE(media_session_observer->IsPlaying(0)); | 247 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
236 | 248 |
237 SystemSuspend(true); | 249 SystemSuspend(true); |
238 | 250 |
239 EXPECT_FALSE(media_session_observer->IsPlaying(0)); | 251 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
240 | 252 |
241 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 253 StartNewPlayer(media_session_observer.get(), |
| 254 media::MediaContentType::Content); |
242 | 255 |
243 EXPECT_FALSE(media_session_observer->IsPlaying(0)); | 256 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
244 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 257 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
245 | 258 |
246 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 259 StartNewPlayer(media_session_observer.get(), |
| 260 media::MediaContentType::Content); |
247 | 261 |
248 EXPECT_FALSE(media_session_observer->IsPlaying(0)); | 262 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
249 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 263 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
250 EXPECT_TRUE(media_session_observer->IsPlaying(2)); | 264 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
251 } | 265 } |
252 | 266 |
253 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 267 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
254 MediaSessionSetVolumeMultiplier) { | 268 MediaSessionSetVolumeMultiplier) { |
255 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 269 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
256 new MockMediaSessionObserver); | 270 new MockMediaSessionObserver); |
257 | 271 |
258 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 272 StartNewPlayer(media_session_observer.get(), |
259 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 273 media::MediaContentType::Content); |
| 274 StartNewPlayer(media_session_observer.get(), |
| 275 media::MediaContentType::Content); |
260 | 276 |
261 double volume_multiplier = 0.2f; | 277 double volume_multiplier = 0.2f; |
262 SystemSetVolumeMultiplier(volume_multiplier); | 278 SystemSetVolumeMultiplier(volume_multiplier); |
263 | 279 |
264 EXPECT_EQ(volume_multiplier, media_session_observer->GetVolumeMultiplier(0)); | 280 EXPECT_EQ(volume_multiplier, media_session_observer->GetVolumeMultiplier(0)); |
265 EXPECT_EQ(volume_multiplier, media_session_observer->GetVolumeMultiplier(1)); | 281 EXPECT_EQ(volume_multiplier, media_session_observer->GetVolumeMultiplier(1)); |
266 | 282 |
267 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 283 StartNewPlayer(media_session_observer.get(), |
| 284 media::MediaContentType::Content); |
268 | 285 |
269 EXPECT_EQ(volume_multiplier, media_session_observer->GetVolumeMultiplier(2)); | 286 EXPECT_EQ(volume_multiplier, media_session_observer->GetVolumeMultiplier(2)); |
270 } | 287 } |
271 | 288 |
272 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, AudioFocusInitialState) { | 289 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, AudioFocusInitialState) { |
273 EXPECT_FALSE(HasAudioFocus()); | 290 EXPECT_FALSE(HasAudioFocus()); |
274 } | 291 } |
275 | 292 |
276 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, StartPlayerGivesFocus) { | 293 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, StartPlayerGivesFocus) { |
277 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 294 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
278 new MockMediaSessionObserver); | 295 new MockMediaSessionObserver); |
279 | 296 |
280 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 297 StartNewPlayer(media_session_observer.get(), |
| 298 media::MediaContentType::Content); |
281 | 299 |
282 EXPECT_TRUE(HasAudioFocus()); | 300 EXPECT_TRUE(HasAudioFocus()); |
283 } | 301 } |
284 | 302 |
285 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, SuspendGivesAwayAudioFocus) { | 303 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, SuspendGivesAwayAudioFocus) { |
286 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 304 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
287 new MockMediaSessionObserver); | 305 new MockMediaSessionObserver); |
288 | 306 |
289 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 307 StartNewPlayer(media_session_observer.get(), |
| 308 media::MediaContentType::Content); |
290 | 309 |
291 SystemSuspend(true); | 310 SystemSuspend(true); |
292 | 311 |
293 EXPECT_FALSE(HasAudioFocus()); | 312 EXPECT_FALSE(HasAudioFocus()); |
294 } | 313 } |
295 | 314 |
296 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, StopGivesAwayAudioFocus) { | 315 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, StopGivesAwayAudioFocus) { |
297 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 316 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
298 new MockMediaSessionObserver); | 317 new MockMediaSessionObserver); |
299 | 318 |
300 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 319 StartNewPlayer(media_session_observer.get(), |
| 320 media::MediaContentType::Content); |
301 | 321 |
302 media_session_->Stop(MediaSession::SuspendType::UI); | 322 media_session_->Stop(MediaSession::SuspendType::UI); |
303 | 323 |
304 EXPECT_FALSE(HasAudioFocus()); | 324 EXPECT_FALSE(HasAudioFocus()); |
305 } | 325 } |
306 | 326 |
307 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumeGivesBackAudioFocus) { | 327 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumeGivesBackAudioFocus) { |
308 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 328 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
309 new MockMediaSessionObserver); | 329 new MockMediaSessionObserver); |
310 | 330 |
311 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 331 StartNewPlayer(media_session_observer.get(), |
| 332 media::MediaContentType::Content); |
312 | 333 |
313 SystemSuspend(true); | 334 SystemSuspend(true); |
314 SystemResume(); | 335 SystemResume(); |
315 | 336 |
316 EXPECT_TRUE(HasAudioFocus()); | 337 EXPECT_TRUE(HasAudioFocus()); |
317 } | 338 } |
318 | 339 |
319 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 340 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
320 RemovingLastPlayerDropsAudioFocus) { | 341 RemovingLastPlayerDropsAudioFocus) { |
321 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 342 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
322 new MockMediaSessionObserver); | 343 new MockMediaSessionObserver); |
323 | 344 |
324 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 345 StartNewPlayer(media_session_observer.get(), |
325 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 346 media::MediaContentType::Content); |
326 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 347 StartNewPlayer(media_session_observer.get(), |
| 348 media::MediaContentType::Content); |
| 349 StartNewPlayer(media_session_observer.get(), |
| 350 media::MediaContentType::Content); |
327 | 351 |
328 RemovePlayer(media_session_observer.get(), 0); | 352 RemovePlayer(media_session_observer.get(), 0); |
329 EXPECT_TRUE(HasAudioFocus()); | 353 EXPECT_TRUE(HasAudioFocus()); |
330 RemovePlayer(media_session_observer.get(), 1); | 354 RemovePlayer(media_session_observer.get(), 1); |
331 EXPECT_TRUE(HasAudioFocus()); | 355 EXPECT_TRUE(HasAudioFocus()); |
332 RemovePlayer(media_session_observer.get(), 2); | 356 RemovePlayer(media_session_observer.get(), 2); |
333 EXPECT_FALSE(HasAudioFocus()); | 357 EXPECT_FALSE(HasAudioFocus()); |
334 } | 358 } |
335 | 359 |
336 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 360 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
337 RemovingLastPlayerFromManyObserversDropsAudioFocus) { | 361 RemovingLastPlayerFromManyObserversDropsAudioFocus) { |
338 std::unique_ptr<MockMediaSessionObserver> media_session_observer_1( | 362 std::unique_ptr<MockMediaSessionObserver> media_session_observer_1( |
339 new MockMediaSessionObserver); | 363 new MockMediaSessionObserver); |
340 std::unique_ptr<MockMediaSessionObserver> media_session_observer_2( | 364 std::unique_ptr<MockMediaSessionObserver> media_session_observer_2( |
341 new MockMediaSessionObserver); | 365 new MockMediaSessionObserver); |
342 std::unique_ptr<MockMediaSessionObserver> media_session_observer_3( | 366 std::unique_ptr<MockMediaSessionObserver> media_session_observer_3( |
343 new MockMediaSessionObserver); | 367 new MockMediaSessionObserver); |
344 | 368 |
345 StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content); | 369 StartNewPlayer(media_session_observer_1.get(), |
346 StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content); | 370 media::MediaContentType::Content); |
347 StartNewPlayer(media_session_observer_3.get(), MediaSession::Type::Content); | 371 StartNewPlayer(media_session_observer_2.get(), |
| 372 media::MediaContentType::Content); |
| 373 StartNewPlayer(media_session_observer_3.get(), |
| 374 media::MediaContentType::Content); |
348 | 375 |
349 RemovePlayer(media_session_observer_1.get(), 0); | 376 RemovePlayer(media_session_observer_1.get(), 0); |
350 EXPECT_TRUE(HasAudioFocus()); | 377 EXPECT_TRUE(HasAudioFocus()); |
351 RemovePlayer(media_session_observer_2.get(), 0); | 378 RemovePlayer(media_session_observer_2.get(), 0); |
352 EXPECT_TRUE(HasAudioFocus()); | 379 EXPECT_TRUE(HasAudioFocus()); |
353 RemovePlayer(media_session_observer_3.get(), 0); | 380 RemovePlayer(media_session_observer_3.get(), 0); |
354 EXPECT_FALSE(HasAudioFocus()); | 381 EXPECT_FALSE(HasAudioFocus()); |
355 } | 382 } |
356 | 383 |
357 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 384 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
358 RemovingAllPlayersFromObserversDropsAudioFocus) { | 385 RemovingAllPlayersFromObserversDropsAudioFocus) { |
359 std::unique_ptr<MockMediaSessionObserver> media_session_observer_1( | 386 std::unique_ptr<MockMediaSessionObserver> media_session_observer_1( |
360 new MockMediaSessionObserver); | 387 new MockMediaSessionObserver); |
361 std::unique_ptr<MockMediaSessionObserver> media_session_observer_2( | 388 std::unique_ptr<MockMediaSessionObserver> media_session_observer_2( |
362 new MockMediaSessionObserver); | 389 new MockMediaSessionObserver); |
363 | 390 |
364 StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content); | 391 StartNewPlayer(media_session_observer_1.get(), |
365 StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content); | 392 media::MediaContentType::Content); |
366 StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content); | 393 StartNewPlayer(media_session_observer_1.get(), |
367 StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content); | 394 media::MediaContentType::Content); |
| 395 StartNewPlayer(media_session_observer_2.get(), |
| 396 media::MediaContentType::Content); |
| 397 StartNewPlayer(media_session_observer_2.get(), |
| 398 media::MediaContentType::Content); |
368 | 399 |
369 RemovePlayers(media_session_observer_1.get()); | 400 RemovePlayers(media_session_observer_1.get()); |
370 EXPECT_TRUE(HasAudioFocus()); | 401 EXPECT_TRUE(HasAudioFocus()); |
371 RemovePlayers(media_session_observer_2.get()); | 402 RemovePlayers(media_session_observer_2.get()); |
372 EXPECT_FALSE(HasAudioFocus()); | 403 EXPECT_FALSE(HasAudioFocus()); |
373 } | 404 } |
374 | 405 |
375 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumePlayGivesAudioFocus) { | 406 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumePlayGivesAudioFocus) { |
376 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 407 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
377 new MockMediaSessionObserver); | 408 new MockMediaSessionObserver); |
378 | 409 |
379 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 410 StartNewPlayer(media_session_observer.get(), |
| 411 media::MediaContentType::Content); |
380 | 412 |
381 RemovePlayer(media_session_observer.get(), 0); | 413 RemovePlayer(media_session_observer.get(), 0); |
382 EXPECT_FALSE(HasAudioFocus()); | 414 EXPECT_FALSE(HasAudioFocus()); |
383 | 415 |
384 EXPECT_TRUE( | 416 EXPECT_TRUE(AddPlayer(media_session_observer.get(), 0, |
385 AddPlayer(media_session_observer.get(), 0, MediaSession::Type::Content)); | 417 media::MediaContentType::Content)); |
386 EXPECT_TRUE(HasAudioFocus()); | 418 EXPECT_TRUE(HasAudioFocus()); |
387 } | 419 } |
388 | 420 |
389 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 421 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
390 ResumeSuspendAreSentOnlyOncePerPlayers) { | 422 ResumeSuspendAreSentOnlyOncePerPlayers) { |
391 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 423 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
392 new MockMediaSessionObserver); | 424 new MockMediaSessionObserver); |
393 | 425 |
394 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 426 StartNewPlayer(media_session_observer.get(), |
395 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 427 media::MediaContentType::Content); |
396 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 428 StartNewPlayer(media_session_observer.get(), |
| 429 media::MediaContentType::Content); |
| 430 StartNewPlayer(media_session_observer.get(), |
| 431 media::MediaContentType::Content); |
397 | 432 |
398 EXPECT_EQ(0, media_session_observer->received_suspend_calls()); | 433 EXPECT_EQ(0, media_session_observer->received_suspend_calls()); |
399 EXPECT_EQ(0, media_session_observer->received_resume_calls()); | 434 EXPECT_EQ(0, media_session_observer->received_resume_calls()); |
400 | 435 |
401 SystemSuspend(true); | 436 SystemSuspend(true); |
402 EXPECT_EQ(3, media_session_observer->received_suspend_calls()); | 437 EXPECT_EQ(3, media_session_observer->received_suspend_calls()); |
403 | 438 |
404 SystemResume(); | 439 SystemResume(); |
405 EXPECT_EQ(3, media_session_observer->received_resume_calls()); | 440 EXPECT_EQ(3, media_session_observer->received_resume_calls()); |
406 } | 441 } |
407 | 442 |
408 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 443 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
409 ResumeSuspendAreSentOnlyOncePerPlayersAddedTwice) { | 444 ResumeSuspendAreSentOnlyOncePerPlayersAddedTwice) { |
410 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 445 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
411 new MockMediaSessionObserver); | 446 new MockMediaSessionObserver); |
412 | 447 |
413 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 448 StartNewPlayer(media_session_observer.get(), |
414 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 449 media::MediaContentType::Content); |
415 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 450 StartNewPlayer(media_session_observer.get(), |
| 451 media::MediaContentType::Content); |
| 452 StartNewPlayer(media_session_observer.get(), |
| 453 media::MediaContentType::Content); |
416 | 454 |
417 // Adding the three players above again. | 455 // Adding the three players above again. |
418 EXPECT_TRUE( | 456 EXPECT_TRUE(AddPlayer(media_session_observer.get(), 0, |
419 AddPlayer(media_session_observer.get(), 0, MediaSession::Type::Content)); | 457 media::MediaContentType::Content)); |
420 EXPECT_TRUE( | 458 EXPECT_TRUE(AddPlayer(media_session_observer.get(), 1, |
421 AddPlayer(media_session_observer.get(), 1, MediaSession::Type::Content)); | 459 media::MediaContentType::Content)); |
422 EXPECT_TRUE( | 460 EXPECT_TRUE(AddPlayer(media_session_observer.get(), 2, |
423 AddPlayer(media_session_observer.get(), 2, MediaSession::Type::Content)); | 461 media::MediaContentType::Content)); |
424 | 462 |
425 EXPECT_EQ(0, media_session_observer->received_suspend_calls()); | 463 EXPECT_EQ(0, media_session_observer->received_suspend_calls()); |
426 EXPECT_EQ(0, media_session_observer->received_resume_calls()); | 464 EXPECT_EQ(0, media_session_observer->received_resume_calls()); |
427 | 465 |
428 SystemSuspend(true); | 466 SystemSuspend(true); |
429 EXPECT_EQ(3, media_session_observer->received_suspend_calls()); | 467 EXPECT_EQ(3, media_session_observer->received_suspend_calls()); |
430 | 468 |
431 SystemResume(); | 469 SystemResume(); |
432 EXPECT_EQ(3, media_session_observer->received_resume_calls()); | 470 EXPECT_EQ(3, media_session_observer->received_resume_calls()); |
433 } | 471 } |
434 | 472 |
435 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 473 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
436 RemovingTheSamePlayerTwiceIsANoop) { | 474 RemovingTheSamePlayerTwiceIsANoop) { |
437 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 475 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
438 new MockMediaSessionObserver); | 476 new MockMediaSessionObserver); |
439 | 477 |
440 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 478 StartNewPlayer(media_session_observer.get(), |
| 479 media::MediaContentType::Content); |
441 | 480 |
442 RemovePlayer(media_session_observer.get(), 0); | 481 RemovePlayer(media_session_observer.get(), 0); |
443 RemovePlayer(media_session_observer.get(), 0); | 482 RemovePlayer(media_session_observer.get(), 0); |
444 } | 483 } |
445 | 484 |
446 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, MediaSessionType) { | 485 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, MediaSessionType) { |
447 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 486 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
448 new MockMediaSessionObserver); | 487 new MockMediaSessionObserver); |
449 | 488 |
450 // Starting a player with a given type should set the session to that type. | 489 // Starting a player with a given type should set the session to that type. |
451 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); | 490 StartNewPlayer(media_session_observer.get(), |
452 EXPECT_EQ(MediaSession::Type::Transient, GetSessionType()); | 491 media::MediaContentType::Transient); |
| 492 EXPECT_EQ(MediaSession::AudioFocusType::Transient, GetSessionType()); |
453 | 493 |
454 // Adding a player of the same type should have no effect on the type. | 494 // Adding a player of the same type should have no effect on the type. |
455 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); | 495 StartNewPlayer(media_session_observer.get(), |
456 EXPECT_EQ(MediaSession::Type::Transient, GetSessionType()); | 496 media::MediaContentType::Transient); |
| 497 EXPECT_EQ(MediaSession::AudioFocusType::Transient, GetSessionType()); |
457 | 498 |
458 // Adding a player of Content type should override the current type. | 499 // Adding a player of Content type should override the current type. |
459 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 500 StartNewPlayer(media_session_observer.get(), |
460 EXPECT_EQ(MediaSession::Type::Content, GetSessionType()); | 501 media::MediaContentType::Content); |
| 502 EXPECT_EQ(MediaSession::AudioFocusType::Content, GetSessionType()); |
461 | 503 |
462 // Adding a player of the Transient type should have no effect on the type. | 504 // Adding a player of the Transient type should have no effect on the type. |
463 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); | 505 StartNewPlayer(media_session_observer.get(), |
464 EXPECT_EQ(MediaSession::Type::Content, GetSessionType()); | 506 media::MediaContentType::Transient); |
| 507 EXPECT_EQ(MediaSession::AudioFocusType::Content, GetSessionType()); |
465 | 508 |
466 EXPECT_TRUE(media_session_observer->IsPlaying(0)); | 509 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
467 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 510 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
468 EXPECT_TRUE(media_session_observer->IsPlaying(2)); | 511 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
469 EXPECT_TRUE(media_session_observer->IsPlaying(3)); | 512 EXPECT_TRUE(media_session_observer->IsPlaying(3)); |
470 | 513 |
471 SystemSuspend(true); | 514 SystemSuspend(true); |
472 | 515 |
473 EXPECT_FALSE(media_session_observer->IsPlaying(0)); | 516 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
474 EXPECT_FALSE(media_session_observer->IsPlaying(1)); | 517 EXPECT_FALSE(media_session_observer->IsPlaying(1)); |
475 EXPECT_FALSE(media_session_observer->IsPlaying(2)); | 518 EXPECT_FALSE(media_session_observer->IsPlaying(2)); |
476 EXPECT_FALSE(media_session_observer->IsPlaying(3)); | 519 EXPECT_FALSE(media_session_observer->IsPlaying(3)); |
477 | 520 |
478 EXPECT_EQ(MediaSession::Type::Content, GetSessionType()); | 521 EXPECT_EQ(MediaSession::AudioFocusType::Content, GetSessionType()); |
479 | 522 |
480 SystemResume(); | 523 SystemResume(); |
481 | 524 |
482 EXPECT_TRUE(media_session_observer->IsPlaying(0)); | 525 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
483 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 526 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
484 EXPECT_TRUE(media_session_observer->IsPlaying(2)); | 527 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
485 EXPECT_TRUE(media_session_observer->IsPlaying(3)); | 528 EXPECT_TRUE(media_session_observer->IsPlaying(3)); |
486 | 529 |
487 EXPECT_EQ(MediaSession::Type::Content, GetSessionType()); | 530 EXPECT_EQ(MediaSession::AudioFocusType::Content, GetSessionType()); |
488 } | 531 } |
489 | 532 |
490 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsShowForContent) { | 533 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsShowForContent) { |
491 EXPECT_CALL(*mock_web_contents_observer(), | 534 EXPECT_CALL(*mock_web_contents_observer(), |
492 MediaSessionStateChanged(true, false, testing::_)); | 535 MediaSessionStateChanged(true, false, testing::_)); |
493 | 536 |
494 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 537 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
495 new MockMediaSessionObserver); | 538 new MockMediaSessionObserver); |
496 | 539 |
497 // Starting a player with a content type should show the media controls. | 540 // Starting a player with a content type should show the media controls. |
498 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 541 StartNewPlayer(media_session_observer.get(), |
| 542 media::MediaContentType::Content); |
499 | 543 |
500 EXPECT_TRUE(IsControllable()); | 544 EXPECT_TRUE(IsControllable()); |
501 EXPECT_FALSE(IsSuspended()); | 545 EXPECT_FALSE(IsSuspended()); |
502 } | 546 } |
503 | 547 |
504 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsNoShowForTransient) { | 548 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsNoShowForTransient) { |
505 EXPECT_CALL(*mock_web_contents_observer(), | 549 EXPECT_CALL(*mock_web_contents_observer(), |
506 MediaSessionStateChanged(false, false, testing::_)); | 550 MediaSessionStateChanged(false, false, testing::_)); |
507 | 551 |
508 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 552 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
509 new MockMediaSessionObserver); | 553 new MockMediaSessionObserver); |
510 | 554 |
511 // Starting a player with a transient type should not show the media controls. | 555 // Starting a player with a transient type should not show the media controls. |
512 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); | 556 StartNewPlayer(media_session_observer.get(), |
| 557 media::MediaContentType::Transient); |
513 | 558 |
514 EXPECT_FALSE(IsControllable()); | 559 EXPECT_FALSE(IsControllable()); |
515 EXPECT_FALSE(IsSuspended()); | 560 EXPECT_FALSE(IsSuspended()); |
516 } | 561 } |
517 | 562 |
518 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsHideWhenStopped) { | 563 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsHideWhenStopped) { |
519 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), | 564 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), |
520 MediaSessionStateChanged(true, false, testing::_)); | 565 MediaSessionStateChanged(true, false, testing::_)); |
521 EXPECT_CALL(*mock_web_contents_observer(), | 566 EXPECT_CALL(*mock_web_contents_observer(), |
522 MediaSessionStateChanged(false, true, testing::_)) | 567 MediaSessionStateChanged(false, true, testing::_)) |
523 .After(showControls); | 568 .After(showControls); |
524 | 569 |
525 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 570 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
526 new MockMediaSessionObserver); | 571 new MockMediaSessionObserver); |
527 | 572 |
528 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 573 StartNewPlayer(media_session_observer.get(), |
| 574 media::MediaContentType::Content); |
529 | 575 |
530 RemovePlayers(media_session_observer.get()); | 576 RemovePlayers(media_session_observer.get()); |
531 | 577 |
532 EXPECT_FALSE(IsControllable()); | 578 EXPECT_FALSE(IsControllable()); |
533 EXPECT_TRUE(IsSuspended()); | 579 EXPECT_TRUE(IsSuspended()); |
534 } | 580 } |
535 | 581 |
536 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsShownAcceptTransient) { | 582 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsShownAcceptTransient) { |
537 EXPECT_CALL(*mock_web_contents_observer(), | 583 EXPECT_CALL(*mock_web_contents_observer(), |
538 MediaSessionStateChanged(true, false, testing::_)); | 584 MediaSessionStateChanged(true, false, testing::_)); |
539 | 585 |
540 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 586 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
541 new MockMediaSessionObserver); | 587 new MockMediaSessionObserver); |
542 | 588 |
543 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 589 StartNewPlayer(media_session_observer.get(), |
| 590 media::MediaContentType::Content); |
544 | 591 |
545 // Transient player join the session without affecting the controls. | 592 // Transient player join the session without affecting the controls. |
546 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); | 593 StartNewPlayer(media_session_observer.get(), |
| 594 media::MediaContentType::Transient); |
547 | 595 |
548 EXPECT_TRUE(IsControllable()); | 596 EXPECT_TRUE(IsControllable()); |
549 EXPECT_FALSE(IsSuspended()); | 597 EXPECT_FALSE(IsSuspended()); |
550 } | 598 } |
551 | 599 |
552 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 600 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
553 ControlsShownAfterContentAdded) { | 601 ControlsShownAfterContentAdded) { |
554 Expectation dontShowControls = EXPECT_CALL(*mock_web_contents_observer(), | 602 Expectation dontShowControls = EXPECT_CALL(*mock_web_contents_observer(), |
555 MediaSessionStateChanged(false, false, testing::_)); | 603 MediaSessionStateChanged(false, false, testing::_)); |
556 EXPECT_CALL(*mock_web_contents_observer(), | 604 EXPECT_CALL(*mock_web_contents_observer(), |
557 MediaSessionStateChanged(true, false, testing::_)) | 605 MediaSessionStateChanged(true, false, testing::_)) |
558 .After(dontShowControls); | 606 .After(dontShowControls); |
559 | 607 |
560 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 608 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
561 new MockMediaSessionObserver); | 609 new MockMediaSessionObserver); |
562 | 610 |
563 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); | 611 StartNewPlayer(media_session_observer.get(), |
| 612 media::MediaContentType::Transient); |
564 | 613 |
565 // The controls are shown when the content player is added. | 614 // The controls are shown when the content player is added. |
566 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 615 StartNewPlayer(media_session_observer.get(), |
| 616 media::MediaContentType::Content); |
567 | 617 |
568 EXPECT_TRUE(IsControllable()); | 618 EXPECT_TRUE(IsControllable()); |
569 EXPECT_FALSE(IsSuspended()); | 619 EXPECT_FALSE(IsSuspended()); |
570 } | 620 } |
571 | 621 |
572 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 622 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
573 ControlsStayIfOnlyOnePlayerHasBeenPaused) { | 623 ControlsStayIfOnlyOnePlayerHasBeenPaused) { |
574 EXPECT_CALL(*mock_web_contents_observer(), | 624 EXPECT_CALL(*mock_web_contents_observer(), |
575 MediaSessionStateChanged(true, false, testing::_)); | 625 MediaSessionStateChanged(true, false, testing::_)); |
576 | 626 |
577 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 627 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
578 new MockMediaSessionObserver); | 628 new MockMediaSessionObserver); |
579 | 629 |
580 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 630 StartNewPlayer(media_session_observer.get(), |
581 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); | 631 media::MediaContentType::Content); |
| 632 StartNewPlayer(media_session_observer.get(), |
| 633 media::MediaContentType::Transient); |
582 | 634 |
583 // Removing only content player doesn't hide the controls since the session | 635 // Removing only content player doesn't hide the controls since the session |
584 // is still active. | 636 // is still active. |
585 RemovePlayer(media_session_observer.get(), 0); | 637 RemovePlayer(media_session_observer.get(), 0); |
586 | 638 |
587 EXPECT_TRUE(IsControllable()); | 639 EXPECT_TRUE(IsControllable()); |
588 EXPECT_FALSE(IsSuspended()); | 640 EXPECT_FALSE(IsSuspended()); |
589 } | 641 } |
590 | 642 |
591 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 643 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
592 ControlsHideWhenTheLastPlayerIsRemoved) { | 644 ControlsHideWhenTheLastPlayerIsRemoved) { |
593 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), | 645 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), |
594 MediaSessionStateChanged(true, false, testing::_)); | 646 MediaSessionStateChanged(true, false, testing::_)); |
595 EXPECT_CALL(*mock_web_contents_observer(), | 647 EXPECT_CALL(*mock_web_contents_observer(), |
596 MediaSessionStateChanged(false, true, testing::_)) | 648 MediaSessionStateChanged(false, true, testing::_)) |
597 .After(showControls); | 649 .After(showControls); |
598 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 650 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
599 new MockMediaSessionObserver); | 651 new MockMediaSessionObserver); |
600 | 652 |
601 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 653 StartNewPlayer(media_session_observer.get(), |
602 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 654 media::MediaContentType::Content); |
| 655 StartNewPlayer(media_session_observer.get(), |
| 656 media::MediaContentType::Content); |
603 | 657 |
604 RemovePlayer(media_session_observer.get(), 0); | 658 RemovePlayer(media_session_observer.get(), 0); |
605 | 659 |
606 EXPECT_TRUE(IsControllable()); | 660 EXPECT_TRUE(IsControllable()); |
607 EXPECT_FALSE(IsSuspended()); | 661 EXPECT_FALSE(IsSuspended()); |
608 | 662 |
609 RemovePlayer(media_session_observer.get(), 1); | 663 RemovePlayer(media_session_observer.get(), 1); |
610 | 664 |
611 EXPECT_FALSE(IsControllable()); | 665 EXPECT_FALSE(IsControllable()); |
612 EXPECT_TRUE(IsSuspended()); | 666 EXPECT_TRUE(IsSuspended()); |
613 } | 667 } |
614 | 668 |
615 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 669 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
616 ControlsHideWhenAllThePlayersAreRemoved) { | 670 ControlsHideWhenAllThePlayersAreRemoved) { |
617 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), | 671 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), |
618 MediaSessionStateChanged(true, false, testing::_)); | 672 MediaSessionStateChanged(true, false, testing::_)); |
619 EXPECT_CALL(*mock_web_contents_observer(), | 673 EXPECT_CALL(*mock_web_contents_observer(), |
620 MediaSessionStateChanged(false, true, testing::_)) | 674 MediaSessionStateChanged(false, true, testing::_)) |
621 .After(showControls); | 675 .After(showControls); |
622 | 676 |
623 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 677 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
624 new MockMediaSessionObserver); | 678 new MockMediaSessionObserver); |
625 | 679 |
626 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 680 StartNewPlayer(media_session_observer.get(), |
627 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 681 media::MediaContentType::Content); |
| 682 StartNewPlayer(media_session_observer.get(), |
| 683 media::MediaContentType::Content); |
628 | 684 |
629 RemovePlayers(media_session_observer.get()); | 685 RemovePlayers(media_session_observer.get()); |
630 | 686 |
631 EXPECT_FALSE(IsControllable()); | 687 EXPECT_FALSE(IsControllable()); |
632 EXPECT_TRUE(IsSuspended()); | 688 EXPECT_TRUE(IsSuspended()); |
633 } | 689 } |
634 | 690 |
635 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 691 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
636 ControlsNotHideWhenTheLastPlayerIsPaused) { | 692 ControlsNotHideWhenTheLastPlayerIsPaused) { |
637 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), | 693 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), |
638 MediaSessionStateChanged(true, false, testing::_)); | 694 MediaSessionStateChanged(true, false, testing::_)); |
639 EXPECT_CALL(*mock_web_contents_observer(), | 695 EXPECT_CALL(*mock_web_contents_observer(), |
640 MediaSessionStateChanged(true, true, testing::_)) | 696 MediaSessionStateChanged(true, true, testing::_)) |
641 .After(showControls); | 697 .After(showControls); |
642 | 698 |
643 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 699 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
644 new MockMediaSessionObserver); | 700 new MockMediaSessionObserver); |
645 | 701 |
646 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 702 StartNewPlayer(media_session_observer.get(), |
647 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 703 media::MediaContentType::Content); |
| 704 StartNewPlayer(media_session_observer.get(), |
| 705 media::MediaContentType::Content); |
648 | 706 |
649 OnPlayerPaused(media_session_observer.get(), 0); | 707 OnPlayerPaused(media_session_observer.get(), 0); |
650 | 708 |
651 EXPECT_TRUE(IsControllable()); | 709 EXPECT_TRUE(IsControllable()); |
652 EXPECT_FALSE(IsSuspended()); | 710 EXPECT_FALSE(IsSuspended()); |
653 | 711 |
654 OnPlayerPaused(media_session_observer.get(), 1); | 712 OnPlayerPaused(media_session_observer.get(), 1); |
655 | 713 |
656 EXPECT_TRUE(IsControllable()); | 714 EXPECT_TRUE(IsControllable()); |
657 EXPECT_TRUE(IsSuspended()); | 715 EXPECT_TRUE(IsSuspended()); |
658 } | 716 } |
659 | 717 |
660 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 718 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
661 SuspendTemporaryUpdatesControls) { | 719 SuspendTemporaryUpdatesControls) { |
662 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), | 720 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), |
663 MediaSessionStateChanged(true, false, testing::_)); | 721 MediaSessionStateChanged(true, false, testing::_)); |
664 EXPECT_CALL(*mock_web_contents_observer(), | 722 EXPECT_CALL(*mock_web_contents_observer(), |
665 MediaSessionStateChanged(true, true, testing::_)) | 723 MediaSessionStateChanged(true, true, testing::_)) |
666 .After(showControls); | 724 .After(showControls); |
667 | 725 |
668 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 726 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
669 new MockMediaSessionObserver); | 727 new MockMediaSessionObserver); |
670 | 728 |
671 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 729 StartNewPlayer(media_session_observer.get(), |
| 730 media::MediaContentType::Content); |
672 | 731 |
673 SystemSuspend(true); | 732 SystemSuspend(true); |
674 | 733 |
675 EXPECT_TRUE(IsControllable()); | 734 EXPECT_TRUE(IsControllable()); |
676 EXPECT_TRUE(IsSuspended()); | 735 EXPECT_TRUE(IsSuspended()); |
677 } | 736 } |
678 | 737 |
679 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsUpdatedWhenResumed) { | 738 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsUpdatedWhenResumed) { |
680 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), | 739 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), |
681 MediaSessionStateChanged(true, false, testing::_)); | 740 MediaSessionStateChanged(true, false, testing::_)); |
682 Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(), | 741 Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(), |
683 MediaSessionStateChanged(true, true, testing::_)).After(showControls); | 742 MediaSessionStateChanged(true, true, testing::_)).After(showControls); |
684 EXPECT_CALL(*mock_web_contents_observer(), | 743 EXPECT_CALL(*mock_web_contents_observer(), |
685 MediaSessionStateChanged(true, false, testing::_)) | 744 MediaSessionStateChanged(true, false, testing::_)) |
686 .After(pauseControls); | 745 .After(pauseControls); |
687 | 746 |
688 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 747 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
689 new MockMediaSessionObserver); | 748 new MockMediaSessionObserver); |
690 | 749 |
691 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 750 StartNewPlayer(media_session_observer.get(), |
| 751 media::MediaContentType::Content); |
692 SystemSuspend(true); | 752 SystemSuspend(true); |
693 SystemResume(); | 753 SystemResume(); |
694 | 754 |
695 EXPECT_TRUE(IsControllable()); | 755 EXPECT_TRUE(IsControllable()); |
696 EXPECT_FALSE(IsSuspended()); | 756 EXPECT_FALSE(IsSuspended()); |
697 } | 757 } |
698 | 758 |
699 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 759 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
700 ControlsHideWhenSessionSuspendedPermanently) { | 760 ControlsHideWhenSessionSuspendedPermanently) { |
701 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), | 761 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), |
702 MediaSessionStateChanged(true, false, testing::_)); | 762 MediaSessionStateChanged(true, false, testing::_)); |
703 EXPECT_CALL(*mock_web_contents_observer(), | 763 EXPECT_CALL(*mock_web_contents_observer(), |
704 MediaSessionStateChanged(false, true, testing::_)) | 764 MediaSessionStateChanged(false, true, testing::_)) |
705 .After(showControls); | 765 .After(showControls); |
706 | 766 |
707 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 767 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
708 new MockMediaSessionObserver); | 768 new MockMediaSessionObserver); |
709 | 769 |
710 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 770 StartNewPlayer(media_session_observer.get(), |
| 771 media::MediaContentType::Content); |
711 | 772 |
712 SystemSuspend(false); | 773 SystemSuspend(false); |
713 | 774 |
714 EXPECT_FALSE(IsControllable()); | 775 EXPECT_FALSE(IsControllable()); |
715 EXPECT_TRUE(IsSuspended()); | 776 EXPECT_TRUE(IsSuspended()); |
716 } | 777 } |
717 | 778 |
718 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 779 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
719 ConstrolsHideWhenSessionStops) { | 780 ConstrolsHideWhenSessionStops) { |
720 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), | 781 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), |
721 MediaSessionStateChanged(true, false, testing::_)); | 782 MediaSessionStateChanged(true, false, testing::_)); |
722 Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(), | 783 Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(), |
723 MediaSessionStateChanged(true, true, testing::_)).After(showControls); | 784 MediaSessionStateChanged(true, true, testing::_)).After(showControls); |
724 EXPECT_CALL(*mock_web_contents_observer(), | 785 EXPECT_CALL(*mock_web_contents_observer(), |
725 MediaSessionStateChanged(false, true, testing::_)) | 786 MediaSessionStateChanged(false, true, testing::_)) |
726 .After(pauseControls); | 787 .After(pauseControls); |
727 | 788 |
728 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 789 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
729 new MockMediaSessionObserver); | 790 new MockMediaSessionObserver); |
730 | 791 |
731 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 792 StartNewPlayer(media_session_observer.get(), |
| 793 media::MediaContentType::Content); |
732 | 794 |
733 media_session_->Stop(MediaSession::SuspendType::UI); | 795 media_session_->Stop(MediaSession::SuspendType::UI); |
734 | 796 |
735 EXPECT_FALSE(IsControllable()); | 797 EXPECT_FALSE(IsControllable()); |
736 EXPECT_TRUE(IsSuspended()); | 798 EXPECT_TRUE(IsSuspended()); |
737 } | 799 } |
738 | 800 |
739 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 801 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
740 ControlsHideWhenSessionChangesFromContentToTransient) { | 802 ControlsHideWhenSessionChangesFromContentToTransient) { |
741 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), | 803 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), |
742 MediaSessionStateChanged(true, false, testing::_)); | 804 MediaSessionStateChanged(true, false, testing::_)); |
743 Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(), | 805 Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(), |
744 MediaSessionStateChanged(true, true, testing::_)).After(showControls); | 806 MediaSessionStateChanged(true, true, testing::_)).After(showControls); |
745 EXPECT_CALL(*mock_web_contents_observer(), | 807 EXPECT_CALL(*mock_web_contents_observer(), |
746 MediaSessionStateChanged(false, false, testing::_)) | 808 MediaSessionStateChanged(false, false, testing::_)) |
747 .After(pauseControls); | 809 .After(pauseControls); |
748 | 810 |
749 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 811 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
750 new MockMediaSessionObserver); | 812 new MockMediaSessionObserver); |
751 | 813 |
752 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 814 StartNewPlayer(media_session_observer.get(), |
| 815 media::MediaContentType::Content); |
753 SystemSuspend(true); | 816 SystemSuspend(true); |
754 | 817 |
755 // This should reset the session and change it to a transient, so | 818 // This should reset the session and change it to a transient, so |
756 // hide the controls. | 819 // hide the controls. |
757 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); | 820 StartNewPlayer(media_session_observer.get(), |
| 821 media::MediaContentType::Transient); |
758 | 822 |
759 EXPECT_FALSE(IsControllable()); | 823 EXPECT_FALSE(IsControllable()); |
760 EXPECT_FALSE(IsSuspended()); | 824 EXPECT_FALSE(IsSuspended()); |
761 } | 825 } |
762 | 826 |
763 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 827 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
764 ControlsUpdatedWhenNewPlayerResetsSession) { | 828 ControlsUpdatedWhenNewPlayerResetsSession) { |
765 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), | 829 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), |
766 MediaSessionStateChanged(true, false, testing::_)); | 830 MediaSessionStateChanged(true, false, testing::_)); |
767 Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(), | 831 Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(), |
768 MediaSessionStateChanged(true, true, testing::_)).After(showControls); | 832 MediaSessionStateChanged(true, true, testing::_)).After(showControls); |
769 EXPECT_CALL(*mock_web_contents_observer(), | 833 EXPECT_CALL(*mock_web_contents_observer(), |
770 MediaSessionStateChanged(true, false, testing::_)) | 834 MediaSessionStateChanged(true, false, testing::_)) |
771 .After(pauseControls); | 835 .After(pauseControls); |
772 | 836 |
773 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 837 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
774 new MockMediaSessionObserver); | 838 new MockMediaSessionObserver); |
775 | 839 |
776 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 840 StartNewPlayer(media_session_observer.get(), |
| 841 media::MediaContentType::Content); |
777 SystemSuspend(true); | 842 SystemSuspend(true); |
778 | 843 |
779 // This should reset the session and update the controls. | 844 // This should reset the session and update the controls. |
780 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 845 StartNewPlayer(media_session_observer.get(), |
| 846 media::MediaContentType::Content); |
781 | 847 |
782 EXPECT_TRUE(IsControllable()); | 848 EXPECT_TRUE(IsControllable()); |
783 EXPECT_FALSE(IsSuspended()); | 849 EXPECT_FALSE(IsSuspended()); |
784 } | 850 } |
785 | 851 |
786 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 852 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
787 ControlsResumedWhenPlayerIsResumed) { | 853 ControlsResumedWhenPlayerIsResumed) { |
788 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), | 854 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), |
789 MediaSessionStateChanged(true, false, testing::_)); | 855 MediaSessionStateChanged(true, false, testing::_)); |
790 Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(), | 856 Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(), |
791 MediaSessionStateChanged(true, true, testing::_)).After(showControls); | 857 MediaSessionStateChanged(true, true, testing::_)).After(showControls); |
792 EXPECT_CALL(*mock_web_contents_observer(), | 858 EXPECT_CALL(*mock_web_contents_observer(), |
793 MediaSessionStateChanged(true, false, testing::_)) | 859 MediaSessionStateChanged(true, false, testing::_)) |
794 .After(pauseControls); | 860 .After(pauseControls); |
795 | 861 |
796 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 862 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
797 new MockMediaSessionObserver); | 863 new MockMediaSessionObserver); |
798 | 864 |
799 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 865 StartNewPlayer(media_session_observer.get(), |
| 866 media::MediaContentType::Content); |
800 SystemSuspend(true); | 867 SystemSuspend(true); |
801 | 868 |
802 // This should resume the session and update the controls. | 869 // This should resume the session and update the controls. |
803 AddPlayer(media_session_observer.get(), 0, MediaSession::Type::Content); | 870 AddPlayer(media_session_observer.get(), 0, media::MediaContentType::Content); |
804 | 871 |
805 EXPECT_TRUE(IsControllable()); | 872 EXPECT_TRUE(IsControllable()); |
806 EXPECT_FALSE(IsSuspended()); | 873 EXPECT_FALSE(IsSuspended()); |
807 } | 874 } |
808 | 875 |
809 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 876 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
810 ControlsUpdatedDueToResumeSessionAction) { | 877 ControlsUpdatedDueToResumeSessionAction) { |
811 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), | 878 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), |
812 MediaSessionStateChanged(true, false, testing::_)); | 879 MediaSessionStateChanged(true, false, testing::_)); |
813 EXPECT_CALL(*mock_web_contents_observer(), | 880 EXPECT_CALL(*mock_web_contents_observer(), |
814 MediaSessionStateChanged(true, true, testing::_)) | 881 MediaSessionStateChanged(true, true, testing::_)) |
815 .After(showControls); | 882 .After(showControls); |
816 | 883 |
817 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 884 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
818 new MockMediaSessionObserver); | 885 new MockMediaSessionObserver); |
819 | 886 |
820 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 887 StartNewPlayer(media_session_observer.get(), |
| 888 media::MediaContentType::Content); |
821 UISuspend(); | 889 UISuspend(); |
822 | 890 |
823 EXPECT_TRUE(IsControllable()); | 891 EXPECT_TRUE(IsControllable()); |
824 EXPECT_TRUE(IsSuspended()); | 892 EXPECT_TRUE(IsSuspended()); |
825 } | 893 } |
826 | 894 |
827 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 895 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
828 ControlsUpdatedDueToSuspendSessionAction) { | 896 ControlsUpdatedDueToSuspendSessionAction) { |
829 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), | 897 Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(), |
830 MediaSessionStateChanged(true, false, testing::_)); | 898 MediaSessionStateChanged(true, false, testing::_)); |
831 Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(), | 899 Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(), |
832 MediaSessionStateChanged(true, true, testing::_)).After(showControls); | 900 MediaSessionStateChanged(true, true, testing::_)).After(showControls); |
833 EXPECT_CALL(*mock_web_contents_observer(), | 901 EXPECT_CALL(*mock_web_contents_observer(), |
834 MediaSessionStateChanged(true, false, testing::_)) | 902 MediaSessionStateChanged(true, false, testing::_)) |
835 .After(pauseControls); | 903 .After(pauseControls); |
836 | 904 |
837 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 905 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
838 new MockMediaSessionObserver); | 906 new MockMediaSessionObserver); |
839 | 907 |
840 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 908 StartNewPlayer(media_session_observer.get(), |
| 909 media::MediaContentType::Content); |
841 UISuspend(); | 910 UISuspend(); |
842 UIResume(); | 911 UIResume(); |
843 | 912 |
844 EXPECT_TRUE(IsControllable()); | 913 EXPECT_TRUE(IsControllable()); |
845 EXPECT_FALSE(IsSuspended()); | 914 EXPECT_FALSE(IsSuspended()); |
846 } | 915 } |
847 | 916 |
848 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 917 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
849 DontResumeBySystemUISuspendedSessions) { | 918 DontResumeBySystemUISuspendedSessions) { |
850 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 919 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
851 new MockMediaSessionObserver); | 920 new MockMediaSessionObserver); |
852 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 921 StartNewPlayer(media_session_observer.get(), |
| 922 media::MediaContentType::Content); |
853 | 923 |
854 UISuspend(); | 924 UISuspend(); |
855 EXPECT_TRUE(IsControllable()); | 925 EXPECT_TRUE(IsControllable()); |
856 EXPECT_TRUE(IsSuspended()); | 926 EXPECT_TRUE(IsSuspended()); |
857 | 927 |
858 SystemResume(); | 928 SystemResume(); |
859 EXPECT_TRUE(IsControllable()); | 929 EXPECT_TRUE(IsControllable()); |
860 EXPECT_TRUE(IsSuspended()); | 930 EXPECT_TRUE(IsSuspended()); |
861 } | 931 } |
862 | 932 |
863 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 933 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
864 AllowUIResumeForSystemSuspend) { | 934 AllowUIResumeForSystemSuspend) { |
865 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 935 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
866 new MockMediaSessionObserver); | 936 new MockMediaSessionObserver); |
867 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 937 StartNewPlayer(media_session_observer.get(), |
| 938 media::MediaContentType::Content); |
868 | 939 |
869 SystemSuspend(true); | 940 SystemSuspend(true); |
870 EXPECT_TRUE(IsControllable()); | 941 EXPECT_TRUE(IsControllable()); |
871 EXPECT_TRUE(IsSuspended()); | 942 EXPECT_TRUE(IsSuspended()); |
872 | 943 |
873 UIResume(); | 944 UIResume(); |
874 EXPECT_TRUE(IsControllable()); | 945 EXPECT_TRUE(IsControllable()); |
875 EXPECT_FALSE(IsSuspended()); | 946 EXPECT_FALSE(IsSuspended()); |
876 } | 947 } |
877 | 948 |
878 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumeSuspendFromUI) { | 949 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumeSuspendFromUI) { |
879 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 950 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
880 new MockMediaSessionObserver); | 951 new MockMediaSessionObserver); |
881 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 952 StartNewPlayer(media_session_observer.get(), |
| 953 media::MediaContentType::Content); |
882 | 954 |
883 UISuspend(); | 955 UISuspend(); |
884 EXPECT_TRUE(IsControllable()); | 956 EXPECT_TRUE(IsControllable()); |
885 EXPECT_TRUE(IsSuspended()); | 957 EXPECT_TRUE(IsSuspended()); |
886 | 958 |
887 UIResume(); | 959 UIResume(); |
888 EXPECT_TRUE(IsControllable()); | 960 EXPECT_TRUE(IsControllable()); |
889 EXPECT_FALSE(IsSuspended()); | 961 EXPECT_FALSE(IsSuspended()); |
890 } | 962 } |
891 | 963 |
892 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumeSuspendFromSystem) { | 964 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumeSuspendFromSystem) { |
893 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 965 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
894 new MockMediaSessionObserver); | 966 new MockMediaSessionObserver); |
895 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 967 StartNewPlayer(media_session_observer.get(), |
| 968 media::MediaContentType::Content); |
896 | 969 |
897 SystemSuspend(true); | 970 SystemSuspend(true); |
898 EXPECT_TRUE(IsControllable()); | 971 EXPECT_TRUE(IsControllable()); |
899 EXPECT_TRUE(IsSuspended()); | 972 EXPECT_TRUE(IsSuspended()); |
900 | 973 |
901 SystemResume(); | 974 SystemResume(); |
902 EXPECT_TRUE(IsControllable()); | 975 EXPECT_TRUE(IsControllable()); |
903 EXPECT_FALSE(IsSuspended()); | 976 EXPECT_FALSE(IsSuspended()); |
904 } | 977 } |
905 | 978 |
906 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, UMA_Suspended_SystemTransient) { | 979 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, UMA_Suspended_SystemTransient) { |
907 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 980 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
908 new MockMediaSessionObserver); | 981 new MockMediaSessionObserver); |
909 base::HistogramTester tester; | 982 base::HistogramTester tester; |
910 | 983 |
911 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 984 StartNewPlayer(media_session_observer.get(), |
| 985 media::MediaContentType::Content); |
912 SystemSuspend(true); | 986 SystemSuspend(true); |
913 | 987 |
914 std::unique_ptr<base::HistogramSamples> samples( | 988 std::unique_ptr<base::HistogramSamples> samples( |
915 tester.GetHistogramSamplesSinceCreation("Media.Session.Suspended")); | 989 tester.GetHistogramSamplesSinceCreation("Media.Session.Suspended")); |
916 EXPECT_EQ(1, samples->TotalCount()); | 990 EXPECT_EQ(1, samples->TotalCount()); |
917 EXPECT_EQ(1, samples->GetCount(0)); // System Transient | 991 EXPECT_EQ(1, samples->GetCount(0)); // System Transient |
918 EXPECT_EQ(0, samples->GetCount(1)); // System Permanent | 992 EXPECT_EQ(0, samples->GetCount(1)); // System Permanent |
919 EXPECT_EQ(0, samples->GetCount(2)); // UI | 993 EXPECT_EQ(0, samples->GetCount(2)); // UI |
920 } | 994 } |
921 | 995 |
922 | 996 |
923 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 997 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
924 UMA_Suspended_SystemPermantent) { | 998 UMA_Suspended_SystemPermantent) { |
925 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 999 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
926 new MockMediaSessionObserver); | 1000 new MockMediaSessionObserver); |
927 base::HistogramTester tester; | 1001 base::HistogramTester tester; |
928 | 1002 |
929 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 1003 StartNewPlayer(media_session_observer.get(), |
| 1004 media::MediaContentType::Content); |
930 SystemSuspend(false); | 1005 SystemSuspend(false); |
931 | 1006 |
932 std::unique_ptr<base::HistogramSamples> samples( | 1007 std::unique_ptr<base::HistogramSamples> samples( |
933 tester.GetHistogramSamplesSinceCreation("Media.Session.Suspended")); | 1008 tester.GetHistogramSamplesSinceCreation("Media.Session.Suspended")); |
934 EXPECT_EQ(1, samples->TotalCount()); | 1009 EXPECT_EQ(1, samples->TotalCount()); |
935 EXPECT_EQ(0, samples->GetCount(0)); // System Transient | 1010 EXPECT_EQ(0, samples->GetCount(0)); // System Transient |
936 EXPECT_EQ(1, samples->GetCount(1)); // System Permanent | 1011 EXPECT_EQ(1, samples->GetCount(1)); // System Permanent |
937 EXPECT_EQ(0, samples->GetCount(2)); // UI | 1012 EXPECT_EQ(0, samples->GetCount(2)); // UI |
938 } | 1013 } |
939 | 1014 |
940 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, UMA_Suspended_UI) { | 1015 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, UMA_Suspended_UI) { |
941 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 1016 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
942 new MockMediaSessionObserver); | 1017 new MockMediaSessionObserver); |
943 base::HistogramTester tester; | 1018 base::HistogramTester tester; |
944 | 1019 |
945 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 1020 StartNewPlayer(media_session_observer.get(), |
| 1021 media::MediaContentType::Content); |
946 UISuspend(); | 1022 UISuspend(); |
947 | 1023 |
948 std::unique_ptr<base::HistogramSamples> samples( | 1024 std::unique_ptr<base::HistogramSamples> samples( |
949 tester.GetHistogramSamplesSinceCreation("Media.Session.Suspended")); | 1025 tester.GetHistogramSamplesSinceCreation("Media.Session.Suspended")); |
950 EXPECT_EQ(1, samples->TotalCount()); | 1026 EXPECT_EQ(1, samples->TotalCount()); |
951 EXPECT_EQ(0, samples->GetCount(0)); // System Transient | 1027 EXPECT_EQ(0, samples->GetCount(0)); // System Transient |
952 EXPECT_EQ(0, samples->GetCount(1)); // System Permanent | 1028 EXPECT_EQ(0, samples->GetCount(1)); // System Permanent |
953 EXPECT_EQ(1, samples->GetCount(2)); // UI | 1029 EXPECT_EQ(1, samples->GetCount(2)); // UI |
954 } | 1030 } |
955 | 1031 |
956 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, UMA_Suspended_Multiple) { | 1032 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, UMA_Suspended_Multiple) { |
957 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 1033 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
958 new MockMediaSessionObserver); | 1034 new MockMediaSessionObserver); |
959 base::HistogramTester tester; | 1035 base::HistogramTester tester; |
960 | 1036 |
961 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 1037 StartNewPlayer(media_session_observer.get(), |
| 1038 media::MediaContentType::Content); |
962 | 1039 |
963 UISuspend(); | 1040 UISuspend(); |
964 UIResume(); | 1041 UIResume(); |
965 | 1042 |
966 SystemSuspend(true); | 1043 SystemSuspend(true); |
967 SystemResume(); | 1044 SystemResume(); |
968 | 1045 |
969 UISuspend(); | 1046 UISuspend(); |
970 UIResume(); | 1047 UIResume(); |
971 | 1048 |
972 SystemSuspend(false); | 1049 SystemSuspend(false); |
973 | 1050 |
974 std::unique_ptr<base::HistogramSamples> samples( | 1051 std::unique_ptr<base::HistogramSamples> samples( |
975 tester.GetHistogramSamplesSinceCreation("Media.Session.Suspended")); | 1052 tester.GetHistogramSamplesSinceCreation("Media.Session.Suspended")); |
976 EXPECT_EQ(4, samples->TotalCount()); | 1053 EXPECT_EQ(4, samples->TotalCount()); |
977 EXPECT_EQ(1, samples->GetCount(0)); // System Transient | 1054 EXPECT_EQ(1, samples->GetCount(0)); // System Transient |
978 EXPECT_EQ(1, samples->GetCount(1)); // System Permanent | 1055 EXPECT_EQ(1, samples->GetCount(1)); // System Permanent |
979 EXPECT_EQ(2, samples->GetCount(2)); // UI | 1056 EXPECT_EQ(2, samples->GetCount(2)); // UI |
980 } | 1057 } |
981 | 1058 |
982 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, UMA_Suspended_Crossing) { | 1059 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, UMA_Suspended_Crossing) { |
983 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 1060 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
984 new MockMediaSessionObserver); | 1061 new MockMediaSessionObserver); |
985 base::HistogramTester tester; | 1062 base::HistogramTester tester; |
986 | 1063 |
987 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 1064 StartNewPlayer(media_session_observer.get(), |
| 1065 media::MediaContentType::Content); |
988 | 1066 |
989 UISuspend(); | 1067 UISuspend(); |
990 SystemSuspend(true); | 1068 SystemSuspend(true); |
991 SystemSuspend(false); | 1069 SystemSuspend(false); |
992 UIResume(); | 1070 UIResume(); |
993 | 1071 |
994 SystemSuspend(true); | 1072 SystemSuspend(true); |
995 SystemSuspend(true); | 1073 SystemSuspend(true); |
996 SystemSuspend(false); | 1074 SystemSuspend(false); |
997 SystemResume(); | 1075 SystemResume(); |
998 | 1076 |
999 std::unique_ptr<base::HistogramSamples> samples( | 1077 std::unique_ptr<base::HistogramSamples> samples( |
1000 tester.GetHistogramSamplesSinceCreation("Media.Session.Suspended")); | 1078 tester.GetHistogramSamplesSinceCreation("Media.Session.Suspended")); |
1001 EXPECT_EQ(2, samples->TotalCount()); | 1079 EXPECT_EQ(2, samples->TotalCount()); |
1002 EXPECT_EQ(1, samples->GetCount(0)); // System Transient | 1080 EXPECT_EQ(1, samples->GetCount(0)); // System Transient |
1003 EXPECT_EQ(0, samples->GetCount(1)); // System Permanent | 1081 EXPECT_EQ(0, samples->GetCount(1)); // System Permanent |
1004 EXPECT_EQ(1, samples->GetCount(2)); // UI | 1082 EXPECT_EQ(1, samples->GetCount(2)); // UI |
1005 } | 1083 } |
1006 | 1084 |
1007 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, UMA_Suspended_Stop) { | 1085 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, UMA_Suspended_Stop) { |
1008 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 1086 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
1009 new MockMediaSessionObserver); | 1087 new MockMediaSessionObserver); |
1010 base::HistogramTester tester; | 1088 base::HistogramTester tester; |
1011 | 1089 |
1012 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 1090 StartNewPlayer(media_session_observer.get(), |
| 1091 media::MediaContentType::Content); |
1013 media_session_->Stop(MediaSession::SuspendType::UI); | 1092 media_session_->Stop(MediaSession::SuspendType::UI); |
1014 | 1093 |
1015 std::unique_ptr<base::HistogramSamples> samples( | 1094 std::unique_ptr<base::HistogramSamples> samples( |
1016 tester.GetHistogramSamplesSinceCreation("Media.Session.Suspended")); | 1095 tester.GetHistogramSamplesSinceCreation("Media.Session.Suspended")); |
1017 EXPECT_EQ(1, samples->TotalCount()); | 1096 EXPECT_EQ(1, samples->TotalCount()); |
1018 EXPECT_EQ(0, samples->GetCount(0)); // System Transient | 1097 EXPECT_EQ(0, samples->GetCount(0)); // System Transient |
1019 EXPECT_EQ(0, samples->GetCount(1)); // System Permanent | 1098 EXPECT_EQ(0, samples->GetCount(1)); // System Permanent |
1020 EXPECT_EQ(1, samples->GetCount(2)); // UI | 1099 EXPECT_EQ(1, samples->GetCount(2)); // UI |
1021 } | 1100 } |
1022 | 1101 |
(...skipping 14 matching lines...) Expand all Loading... |
1037 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 1116 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
1038 new MockMediaSessionObserver); | 1117 new MockMediaSessionObserver); |
1039 base::HistogramTester tester; | 1118 base::HistogramTester tester; |
1040 | 1119 |
1041 MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper(); | 1120 MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper(); |
1042 base::SimpleTestTickClock* clock = new base::SimpleTestTickClock(); | 1121 base::SimpleTestTickClock* clock = new base::SimpleTestTickClock(); |
1043 clock->SetNowTicks(base::TimeTicks::Now()); | 1122 clock->SetNowTicks(base::TimeTicks::Now()); |
1044 media_session_uma_helper->SetClockForTest( | 1123 media_session_uma_helper->SetClockForTest( |
1045 std::unique_ptr<base::SimpleTestTickClock>(clock)); | 1124 std::unique_ptr<base::SimpleTestTickClock>(clock)); |
1046 | 1125 |
1047 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 1126 StartNewPlayer(media_session_observer.get(), |
| 1127 media::MediaContentType::Content); |
1048 | 1128 |
1049 clock->Advance(base::TimeDelta::FromMilliseconds(1000)); | 1129 clock->Advance(base::TimeDelta::FromMilliseconds(1000)); |
1050 media_session_->Stop(MediaSession::SuspendType::UI); | 1130 media_session_->Stop(MediaSession::SuspendType::UI); |
1051 | 1131 |
1052 std::unique_ptr<base::HistogramSamples> samples( | 1132 std::unique_ptr<base::HistogramSamples> samples( |
1053 tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime")); | 1133 tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime")); |
1054 EXPECT_EQ(1, samples->TotalCount()); | 1134 EXPECT_EQ(1, samples->TotalCount()); |
1055 EXPECT_EQ(1, samples->GetCount(1000)); | 1135 EXPECT_EQ(1, samples->GetCount(1000)); |
1056 } | 1136 } |
1057 | 1137 |
1058 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 1138 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
1059 UMA_ActiveTime_ActivationWithUISuspension) { | 1139 UMA_ActiveTime_ActivationWithUISuspension) { |
1060 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 1140 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
1061 new MockMediaSessionObserver); | 1141 new MockMediaSessionObserver); |
1062 base::HistogramTester tester; | 1142 base::HistogramTester tester; |
1063 | 1143 |
1064 MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper(); | 1144 MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper(); |
1065 base::SimpleTestTickClock* clock = new base::SimpleTestTickClock(); | 1145 base::SimpleTestTickClock* clock = new base::SimpleTestTickClock(); |
1066 clock->SetNowTicks(base::TimeTicks::Now()); | 1146 clock->SetNowTicks(base::TimeTicks::Now()); |
1067 media_session_uma_helper->SetClockForTest( | 1147 media_session_uma_helper->SetClockForTest( |
1068 std::unique_ptr<base::SimpleTestTickClock>(clock)); | 1148 std::unique_ptr<base::SimpleTestTickClock>(clock)); |
1069 | 1149 |
1070 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 1150 StartNewPlayer(media_session_observer.get(), |
| 1151 media::MediaContentType::Content); |
1071 | 1152 |
1072 clock->Advance(base::TimeDelta::FromMilliseconds(1000)); | 1153 clock->Advance(base::TimeDelta::FromMilliseconds(1000)); |
1073 UISuspend(); | 1154 UISuspend(); |
1074 | 1155 |
1075 clock->Advance(base::TimeDelta::FromMilliseconds(2000)); | 1156 clock->Advance(base::TimeDelta::FromMilliseconds(2000)); |
1076 UIResume(); | 1157 UIResume(); |
1077 | 1158 |
1078 clock->Advance(base::TimeDelta::FromMilliseconds(1000)); | 1159 clock->Advance(base::TimeDelta::FromMilliseconds(1000)); |
1079 media_session_->Stop(MediaSession::SuspendType::UI); | 1160 media_session_->Stop(MediaSession::SuspendType::UI); |
1080 | 1161 |
1081 std::unique_ptr<base::HistogramSamples> samples( | 1162 std::unique_ptr<base::HistogramSamples> samples( |
1082 tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime")); | 1163 tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime")); |
1083 EXPECT_EQ(1, samples->TotalCount()); | 1164 EXPECT_EQ(1, samples->TotalCount()); |
1084 EXPECT_EQ(1, samples->GetCount(2000)); | 1165 EXPECT_EQ(1, samples->GetCount(2000)); |
1085 } | 1166 } |
1086 | 1167 |
1087 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 1168 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
1088 UMA_ActiveTime_ActivationWithSystemSuspension) { | 1169 UMA_ActiveTime_ActivationWithSystemSuspension) { |
1089 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 1170 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
1090 new MockMediaSessionObserver); | 1171 new MockMediaSessionObserver); |
1091 base::HistogramTester tester; | 1172 base::HistogramTester tester; |
1092 | 1173 |
1093 MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper(); | 1174 MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper(); |
1094 base::SimpleTestTickClock* clock = new base::SimpleTestTickClock(); | 1175 base::SimpleTestTickClock* clock = new base::SimpleTestTickClock(); |
1095 clock->SetNowTicks(base::TimeTicks::Now()); | 1176 clock->SetNowTicks(base::TimeTicks::Now()); |
1096 media_session_uma_helper->SetClockForTest( | 1177 media_session_uma_helper->SetClockForTest( |
1097 std::unique_ptr<base::SimpleTestTickClock>(clock)); | 1178 std::unique_ptr<base::SimpleTestTickClock>(clock)); |
1098 | 1179 |
1099 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 1180 StartNewPlayer(media_session_observer.get(), |
| 1181 media::MediaContentType::Content); |
1100 | 1182 |
1101 clock->Advance(base::TimeDelta::FromMilliseconds(1000)); | 1183 clock->Advance(base::TimeDelta::FromMilliseconds(1000)); |
1102 SystemSuspend(true); | 1184 SystemSuspend(true); |
1103 | 1185 |
1104 clock->Advance(base::TimeDelta::FromMilliseconds(2000)); | 1186 clock->Advance(base::TimeDelta::FromMilliseconds(2000)); |
1105 SystemResume(); | 1187 SystemResume(); |
1106 | 1188 |
1107 clock->Advance(base::TimeDelta::FromMilliseconds(1000)); | 1189 clock->Advance(base::TimeDelta::FromMilliseconds(1000)); |
1108 media_session_->Stop(MediaSession::SuspendType::UI); | 1190 media_session_->Stop(MediaSession::SuspendType::UI); |
1109 | 1191 |
1110 std::unique_ptr<base::HistogramSamples> samples( | 1192 std::unique_ptr<base::HistogramSamples> samples( |
1111 tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime")); | 1193 tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime")); |
1112 EXPECT_EQ(1, samples->TotalCount()); | 1194 EXPECT_EQ(1, samples->TotalCount()); |
1113 EXPECT_EQ(1, samples->GetCount(2000)); | 1195 EXPECT_EQ(1, samples->GetCount(2000)); |
1114 } | 1196 } |
1115 | 1197 |
1116 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 1198 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
1117 UMA_ActiveTime_ActivateSuspendedButNotStopped) { | 1199 UMA_ActiveTime_ActivateSuspendedButNotStopped) { |
1118 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 1200 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
1119 new MockMediaSessionObserver); | 1201 new MockMediaSessionObserver); |
1120 base::HistogramTester tester; | 1202 base::HistogramTester tester; |
1121 | 1203 |
1122 MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper(); | 1204 MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper(); |
1123 base::SimpleTestTickClock* clock = new base::SimpleTestTickClock(); | 1205 base::SimpleTestTickClock* clock = new base::SimpleTestTickClock(); |
1124 clock->SetNowTicks(base::TimeTicks::Now()); | 1206 clock->SetNowTicks(base::TimeTicks::Now()); |
1125 media_session_uma_helper->SetClockForTest( | 1207 media_session_uma_helper->SetClockForTest( |
1126 std::unique_ptr<base::SimpleTestTickClock>(clock)); | 1208 std::unique_ptr<base::SimpleTestTickClock>(clock)); |
1127 | 1209 |
1128 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 1210 StartNewPlayer(media_session_observer.get(), |
| 1211 media::MediaContentType::Content); |
1129 clock->Advance(base::TimeDelta::FromMilliseconds(500)); | 1212 clock->Advance(base::TimeDelta::FromMilliseconds(500)); |
1130 SystemSuspend(true); | 1213 SystemSuspend(true); |
1131 | 1214 |
1132 { | 1215 { |
1133 std::unique_ptr<base::HistogramSamples> samples( | 1216 std::unique_ptr<base::HistogramSamples> samples( |
1134 tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime")); | 1217 tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime")); |
1135 EXPECT_EQ(0, samples->TotalCount()); | 1218 EXPECT_EQ(0, samples->TotalCount()); |
1136 } | 1219 } |
1137 | 1220 |
1138 SystemResume(); | 1221 SystemResume(); |
(...skipping 12 matching lines...) Expand all Loading... |
1151 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 1234 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
1152 new MockMediaSessionObserver); | 1235 new MockMediaSessionObserver); |
1153 base::HistogramTester tester; | 1236 base::HistogramTester tester; |
1154 | 1237 |
1155 MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper(); | 1238 MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper(); |
1156 base::SimpleTestTickClock* clock = new base::SimpleTestTickClock(); | 1239 base::SimpleTestTickClock* clock = new base::SimpleTestTickClock(); |
1157 clock->SetNowTicks(base::TimeTicks::Now()); | 1240 clock->SetNowTicks(base::TimeTicks::Now()); |
1158 media_session_uma_helper->SetClockForTest( | 1241 media_session_uma_helper->SetClockForTest( |
1159 std::unique_ptr<base::SimpleTestTickClock>(clock)); | 1242 std::unique_ptr<base::SimpleTestTickClock>(clock)); |
1160 | 1243 |
1161 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 1244 StartNewPlayer(media_session_observer.get(), |
| 1245 media::MediaContentType::Content); |
1162 clock->Advance(base::TimeDelta::FromMilliseconds(500)); | 1246 clock->Advance(base::TimeDelta::FromMilliseconds(500)); |
1163 SystemSuspend(true); | 1247 SystemSuspend(true); |
1164 media_session_->Stop(MediaSession::SuspendType::UI); | 1248 media_session_->Stop(MediaSession::SuspendType::UI); |
1165 | 1249 |
1166 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 1250 StartNewPlayer(media_session_observer.get(), |
| 1251 media::MediaContentType::Content); |
1167 clock->Advance(base::TimeDelta::FromMilliseconds(5000)); | 1252 clock->Advance(base::TimeDelta::FromMilliseconds(5000)); |
1168 SystemResume(); | 1253 SystemResume(); |
1169 media_session_->Stop(MediaSession::SuspendType::UI); | 1254 media_session_->Stop(MediaSession::SuspendType::UI); |
1170 | 1255 |
1171 std::unique_ptr<base::HistogramSamples> samples( | 1256 std::unique_ptr<base::HistogramSamples> samples( |
1172 tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime")); | 1257 tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime")); |
1173 EXPECT_EQ(2, samples->TotalCount()); | 1258 EXPECT_EQ(2, samples->TotalCount()); |
1174 EXPECT_EQ(1, samples->GetCount(500)); | 1259 EXPECT_EQ(1, samples->GetCount(500)); |
1175 EXPECT_EQ(1, samples->GetCount(5000)); | 1260 EXPECT_EQ(1, samples->GetCount(5000)); |
1176 } | 1261 } |
1177 | 1262 |
1178 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 1263 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
1179 UMA_ActiveTime_MultipleActivations) { | 1264 UMA_ActiveTime_MultipleActivations) { |
1180 std::unique_ptr<MockMediaSessionObserver> media_session_observer( | 1265 std::unique_ptr<MockMediaSessionObserver> media_session_observer( |
1181 new MockMediaSessionObserver); | 1266 new MockMediaSessionObserver); |
1182 base::HistogramTester tester; | 1267 base::HistogramTester tester; |
1183 | 1268 |
1184 MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper(); | 1269 MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper(); |
1185 base::SimpleTestTickClock* clock = new base::SimpleTestTickClock(); | 1270 base::SimpleTestTickClock* clock = new base::SimpleTestTickClock(); |
1186 clock->SetNowTicks(base::TimeTicks::Now()); | 1271 clock->SetNowTicks(base::TimeTicks::Now()); |
1187 media_session_uma_helper->SetClockForTest( | 1272 media_session_uma_helper->SetClockForTest( |
1188 std::unique_ptr<base::SimpleTestTickClock>(clock)); | 1273 std::unique_ptr<base::SimpleTestTickClock>(clock)); |
1189 | 1274 |
1190 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 1275 StartNewPlayer(media_session_observer.get(), |
| 1276 media::MediaContentType::Content); |
1191 clock->Advance(base::TimeDelta::FromMilliseconds(10000)); | 1277 clock->Advance(base::TimeDelta::FromMilliseconds(10000)); |
1192 RemovePlayer(media_session_observer.get(), 0); | 1278 RemovePlayer(media_session_observer.get(), 0); |
1193 | 1279 |
1194 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | 1280 StartNewPlayer(media_session_observer.get(), |
| 1281 media::MediaContentType::Content); |
1195 clock->Advance(base::TimeDelta::FromMilliseconds(1000)); | 1282 clock->Advance(base::TimeDelta::FromMilliseconds(1000)); |
1196 media_session_->Stop(MediaSession::SuspendType::UI); | 1283 media_session_->Stop(MediaSession::SuspendType::UI); |
1197 | 1284 |
1198 std::unique_ptr<base::HistogramSamples> samples( | 1285 std::unique_ptr<base::HistogramSamples> samples( |
1199 tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime")); | 1286 tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime")); |
1200 EXPECT_EQ(2, samples->TotalCount()); | 1287 EXPECT_EQ(2, samples->TotalCount()); |
1201 EXPECT_EQ(1, samples->GetCount(1000)); | 1288 EXPECT_EQ(1, samples->GetCount(1000)); |
1202 EXPECT_EQ(1, samples->GetCount(10000)); | 1289 EXPECT_EQ(1, samples->GetCount(10000)); |
1203 } | 1290 } |
OLD | NEW |