| OLD | NEW |
|---|
| (Empty) | |
| 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 |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "content/browser/media/android/media_session.h" |
| 6 |
| 7 #include <list> |
| 8 #include <vector> |
| 9 |
| 10 #include "content/browser/media/android/media_session_observer.h" |
| 11 #include "content/public/test/content_browser_test.h" |
| 12 #include "content/shell/browser/shell.h" |
| 13 |
| 14 namespace content { |
| 15 |
| 16 class MockMediaSessionObserver : public MediaSessionObserver { |
| 17 public: |
| 18 MockMediaSessionObserver() |
| 19 : received_resume_calls_(0), |
| 20 received_suspend_calls_(0) { |
| 21 } |
| 22 |
| 23 ~MockMediaSessionObserver() override = default; |
| 24 |
| 25 // Implements MediaSessionObserver. |
| 26 void OnSuspend(int player_id) override { |
| 27 DCHECK(player_id >= 0); |
| 28 DCHECK(players_.size() > static_cast<size_t>(player_id)); |
| 29 |
| 30 ++received_suspend_calls_; |
| 31 players_[player_id] = false; |
| 32 } |
| 33 void OnResume(int player_id) override { |
| 34 DCHECK(player_id >= 0); |
| 35 DCHECK(players_.size() > static_cast<size_t>(player_id)); |
| 36 |
| 37 ++received_resume_calls_; |
| 38 players_[player_id] = true; |
| 39 } |
| 40 |
| 41 int StartNewPlayer() { |
| 42 players_.push_back(true); |
| 43 return players_.size() - 1; |
| 44 } |
| 45 |
| 46 bool IsPlaying(size_t player_id) { |
| 47 DCHECK(players_.size() > player_id); |
| 48 return players_[player_id]; |
| 49 } |
| 50 |
| 51 void SetPlaying(size_t player_id, bool playing) { |
| 52 DCHECK(players_.size() > player_id); |
| 53 players_[player_id] = playing; |
| 54 } |
| 55 |
| 56 int received_suspend_calls() const { |
| 57 return received_suspend_calls_; |
| 58 } |
| 59 |
| 60 int received_resume_calls() const { |
| 61 return received_resume_calls_; |
| 62 } |
| 63 |
| 64 private: |
| 65 // Basic representation of the players. The position in the vector is the |
| 66 // player_id. The value of the vector is the playing status. |
| 67 std::vector<bool> players_; |
| 68 |
| 69 int received_resume_calls_; |
| 70 int received_suspend_calls_; |
| 71 }; |
| 72 |
| 73 class MediaSessionBrowserTest : public ContentBrowserTest { |
| 74 protected: |
| 75 MediaSessionBrowserTest() = default; |
| 76 |
| 77 void DisableNativeBackend(MediaSession* media_session) { |
| 78 media_session->ResetJavaRefForTest(); |
| 79 } |
| 80 |
| 81 void StartNewPlayer(MediaSession* media_session, |
| 82 MockMediaSessionObserver* media_session_observer, |
| 83 MediaSession::Type type) { |
| 84 bool result = media_session->AddPlayer( |
| 85 media_session_observer, |
| 86 media_session_observer->StartNewPlayer(), |
| 87 type); |
| 88 EXPECT_TRUE(result); |
| 89 } |
| 90 |
| 91 void SuspendSession(MediaSession* media_session) { |
| 92 media_session->OnSuspend(); |
| 93 } |
| 94 |
| 95 void ResumeSession(MediaSession* media_session) { |
| 96 media_session->OnResume(); |
| 97 } |
| 98 |
| 99 bool HasAudioFocus(MediaSession* media_session) { |
| 100 return media_session->has_audio_focus_for_test(); |
| 101 } |
| 102 |
| 103 MediaSession::Type GetSessionType(MediaSession* media_session) { |
| 104 return media_session->audio_focus_type_for_test(); |
| 105 } |
| 106 |
| 107 private: |
| 108 DISALLOW_COPY_AND_ASSIGN(MediaSessionBrowserTest); |
| 109 }; |
| 110 |
| 111 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 112 PlayersFromSameObserverDoNotStopEachOtherInSameSession) { |
| 113 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 114 ASSERT_TRUE(media_session); |
| 115 DisableNativeBackend(media_session); |
| 116 |
| 117 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 118 new MockMediaSessionObserver); |
| 119 |
| 120 StartNewPlayer(media_session, media_session_observer.get(), |
| 121 MediaSession::Type::Content); |
| 122 StartNewPlayer(media_session, media_session_observer.get(), |
| 123 MediaSession::Type::Content); |
| 124 StartNewPlayer(media_session, media_session_observer.get(), |
| 125 MediaSession::Type::Content); |
| 126 |
| 127 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
| 128 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
| 129 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
| 130 |
| 131 media_session->RemovePlayers(media_session_observer.get()); |
| 132 } |
| 133 |
| 134 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 135 PlayersFromManyObserverDoNotStopEachOtherInSameSession) { |
| 136 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 137 ASSERT_TRUE(media_session); |
| 138 DisableNativeBackend(media_session); |
| 139 |
| 140 scoped_ptr<MockMediaSessionObserver> media_session_observer_1( |
| 141 new MockMediaSessionObserver); |
| 142 scoped_ptr<MockMediaSessionObserver> media_session_observer_2( |
| 143 new MockMediaSessionObserver); |
| 144 scoped_ptr<MockMediaSessionObserver> media_session_observer_3( |
| 145 new MockMediaSessionObserver); |
| 146 |
| 147 StartNewPlayer(media_session, media_session_observer_1.get(), |
| 148 MediaSession::Type::Content); |
| 149 StartNewPlayer(media_session, media_session_observer_2.get(), |
| 150 MediaSession::Type::Content); |
| 151 StartNewPlayer(media_session, media_session_observer_3.get(), |
| 152 MediaSession::Type::Content); |
| 153 |
| 154 EXPECT_TRUE(media_session_observer_1->IsPlaying(0)); |
| 155 EXPECT_TRUE(media_session_observer_2->IsPlaying(0)); |
| 156 EXPECT_TRUE(media_session_observer_3->IsPlaying(0)); |
| 157 |
| 158 media_session->RemovePlayers(media_session_observer_1.get()); |
| 159 media_session->RemovePlayers(media_session_observer_2.get()); |
| 160 media_session->RemovePlayers(media_session_observer_3.get()); |
| 161 } |
| 162 |
| 163 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 164 SuspendedMediaSessionStopsPlayers) { |
| 165 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 166 ASSERT_TRUE(media_session); |
| 167 DisableNativeBackend(media_session); |
| 168 |
| 169 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 170 new MockMediaSessionObserver); |
| 171 |
| 172 StartNewPlayer(media_session, media_session_observer.get(), |
| 173 MediaSession::Type::Content); |
| 174 StartNewPlayer(media_session, media_session_observer.get(), |
| 175 MediaSession::Type::Content); |
| 176 StartNewPlayer(media_session, media_session_observer.get(), |
| 177 MediaSession::Type::Content); |
| 178 |
| 179 SuspendSession(media_session); |
| 180 |
| 181 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
| 182 EXPECT_FALSE(media_session_observer->IsPlaying(1)); |
| 183 EXPECT_FALSE(media_session_observer->IsPlaying(2)); |
| 184 |
| 185 media_session->RemovePlayers(media_session_observer.get()); |
| 186 } |
| 187 |
| 188 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 189 ResumedMediaSessionRestartsPlayers) { |
| 190 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 191 ASSERT_TRUE(media_session); |
| 192 DisableNativeBackend(media_session); |
| 193 |
| 194 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 195 new MockMediaSessionObserver); |
| 196 |
| 197 StartNewPlayer(media_session, media_session_observer.get(), |
| 198 MediaSession::Type::Content); |
| 199 StartNewPlayer(media_session, media_session_observer.get(), |
| 200 MediaSession::Type::Content); |
| 201 StartNewPlayer(media_session, media_session_observer.get(), |
| 202 MediaSession::Type::Content); |
| 203 |
| 204 SuspendSession(media_session); |
| 205 ResumeSession(media_session); |
| 206 |
| 207 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
| 208 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
| 209 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
| 210 |
| 211 media_session->RemovePlayers(media_session_observer.get()); |
| 212 } |
| 213 |
| 214 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 215 StartedPlayerOnSuspendedSessionPlaysAlone) { |
| 216 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 217 ASSERT_TRUE(media_session); |
| 218 DisableNativeBackend(media_session); |
| 219 |
| 220 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 221 new MockMediaSessionObserver); |
| 222 |
| 223 StartNewPlayer(media_session, media_session_observer.get(), |
| 224 MediaSession::Type::Content); |
| 225 |
| 226 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
| 227 |
| 228 SuspendSession(media_session); |
| 229 |
| 230 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
| 231 |
| 232 StartNewPlayer(media_session, media_session_observer.get(), |
| 233 MediaSession::Type::Content); |
| 234 |
| 235 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
| 236 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
| 237 |
| 238 StartNewPlayer(media_session, media_session_observer.get(), |
| 239 MediaSession::Type::Content); |
| 240 |
| 241 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
| 242 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
| 243 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
| 244 |
| 245 media_session->RemovePlayers(media_session_observer.get()); |
| 246 } |
| 247 |
| 248 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, AudioFocusInitialState) { |
| 249 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 250 ASSERT_TRUE(media_session); |
| 251 DisableNativeBackend(media_session); |
| 252 |
| 253 EXPECT_FALSE(HasAudioFocus(media_session)); |
| 254 } |
| 255 |
| 256 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, StartPlayerGivesFocus) { |
| 257 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 258 ASSERT_TRUE(media_session); |
| 259 DisableNativeBackend(media_session); |
| 260 |
| 261 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 262 new MockMediaSessionObserver); |
| 263 |
| 264 StartNewPlayer(media_session, media_session_observer.get(), |
| 265 MediaSession::Type::Content); |
| 266 |
| 267 EXPECT_TRUE(HasAudioFocus(media_session)); |
| 268 |
| 269 media_session->RemovePlayers(media_session_observer.get()); |
| 270 } |
| 271 |
| 272 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, SuspendGivesAwayAudioFocus) { |
| 273 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 274 ASSERT_TRUE(media_session); |
| 275 DisableNativeBackend(media_session); |
| 276 |
| 277 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 278 new MockMediaSessionObserver); |
| 279 |
| 280 StartNewPlayer(media_session, media_session_observer.get(), |
| 281 MediaSession::Type::Content); |
| 282 |
| 283 SuspendSession(media_session); |
| 284 |
| 285 EXPECT_FALSE(HasAudioFocus(media_session)); |
| 286 |
| 287 media_session->RemovePlayers(media_session_observer.get()); |
| 288 } |
| 289 |
| 290 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumeGivesBackAudioFocus) { |
| 291 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 292 ASSERT_TRUE(media_session); |
| 293 DisableNativeBackend(media_session); |
| 294 |
| 295 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 296 new MockMediaSessionObserver); |
| 297 |
| 298 StartNewPlayer(media_session, media_session_observer.get(), |
| 299 MediaSession::Type::Content); |
| 300 |
| 301 SuspendSession(media_session); |
| 302 ResumeSession(media_session); |
| 303 |
| 304 EXPECT_TRUE(HasAudioFocus(media_session)); |
| 305 |
| 306 media_session->RemovePlayers(media_session_observer.get()); |
| 307 } |
| 308 |
| 309 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 310 RemovingLastPlayerDropsAudioFocus_1) { |
| 311 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 312 ASSERT_TRUE(media_session); |
| 313 DisableNativeBackend(media_session); |
| 314 |
| 315 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 316 new MockMediaSessionObserver); |
| 317 |
| 318 StartNewPlayer(media_session, media_session_observer.get(), |
| 319 MediaSession::Type::Content); |
| 320 StartNewPlayer(media_session, media_session_observer.get(), |
| 321 MediaSession::Type::Content); |
| 322 StartNewPlayer(media_session, media_session_observer.get(), |
| 323 MediaSession::Type::Content); |
| 324 |
| 325 media_session->RemovePlayer(media_session_observer.get(), 0); |
| 326 EXPECT_TRUE(HasAudioFocus(media_session)); |
| 327 media_session->RemovePlayer(media_session_observer.get(), 1); |
| 328 EXPECT_TRUE(HasAudioFocus(media_session)); |
| 329 media_session->RemovePlayer(media_session_observer.get(), 2); |
| 330 EXPECT_FALSE(HasAudioFocus(media_session)); |
| 331 } |
| 332 |
| 333 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 334 RemovingLastPlayerDropsAudioFocus_2) { |
| 335 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 336 ASSERT_TRUE(media_session); |
| 337 DisableNativeBackend(media_session); |
| 338 |
| 339 scoped_ptr<MockMediaSessionObserver> media_session_observer_1( |
| 340 new MockMediaSessionObserver); |
| 341 scoped_ptr<MockMediaSessionObserver> media_session_observer_2( |
| 342 new MockMediaSessionObserver); |
| 343 scoped_ptr<MockMediaSessionObserver> media_session_observer_3( |
| 344 new MockMediaSessionObserver); |
| 345 |
| 346 StartNewPlayer(media_session, media_session_observer_1.get(), |
| 347 MediaSession::Type::Content); |
| 348 StartNewPlayer(media_session, media_session_observer_2.get(), |
| 349 MediaSession::Type::Content); |
| 350 StartNewPlayer(media_session, media_session_observer_3.get(), |
| 351 MediaSession::Type::Content); |
| 352 |
| 353 media_session->RemovePlayer(media_session_observer_1.get(), 0); |
| 354 EXPECT_TRUE(HasAudioFocus(media_session)); |
| 355 media_session->RemovePlayer(media_session_observer_2.get(), 0); |
| 356 EXPECT_TRUE(HasAudioFocus(media_session)); |
| 357 media_session->RemovePlayer(media_session_observer_3.get(), 0); |
| 358 EXPECT_FALSE(HasAudioFocus(media_session)); |
| 359 } |
| 360 |
| 361 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 362 RemovingLastPlayerDropsAudioFocus_3) { |
| 363 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 364 ASSERT_TRUE(media_session); |
| 365 DisableNativeBackend(media_session); |
| 366 |
| 367 scoped_ptr<MockMediaSessionObserver> media_session_observer_1( |
| 368 new MockMediaSessionObserver); |
| 369 scoped_ptr<MockMediaSessionObserver> media_session_observer_2( |
| 370 new MockMediaSessionObserver); |
| 371 |
| 372 StartNewPlayer(media_session, media_session_observer_1.get(), |
| 373 MediaSession::Type::Content); |
| 374 StartNewPlayer(media_session, media_session_observer_1.get(), |
| 375 MediaSession::Type::Content); |
| 376 StartNewPlayer(media_session, media_session_observer_2.get(), |
| 377 MediaSession::Type::Content); |
| 378 StartNewPlayer(media_session, media_session_observer_2.get(), |
| 379 MediaSession::Type::Content); |
| 380 |
| 381 media_session->RemovePlayers(media_session_observer_1.get()); |
| 382 EXPECT_TRUE(HasAudioFocus(media_session)); |
| 383 media_session->RemovePlayers(media_session_observer_2.get()); |
| 384 EXPECT_FALSE(HasAudioFocus(media_session)); |
| 385 } |
| 386 |
| 387 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumePlayGivesAudioFocus) { |
| 388 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 389 ASSERT_TRUE(media_session); |
| 390 DisableNativeBackend(media_session); |
| 391 |
| 392 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 393 new MockMediaSessionObserver); |
| 394 |
| 395 StartNewPlayer(media_session, media_session_observer.get(), |
| 396 MediaSession::Type::Content); |
| 397 |
| 398 media_session->RemovePlayer(media_session_observer.get(), 0); |
| 399 EXPECT_FALSE(HasAudioFocus(media_session)); |
| 400 |
| 401 EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 0, |
| 402 MediaSession::Type::Content)); |
| 403 EXPECT_TRUE(HasAudioFocus(media_session)); |
| 404 |
| 405 media_session->RemovePlayers(media_session_observer.get()); |
| 406 } |
| 407 |
| 408 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 409 ResumeSuspendAreSentOnlyOncePerPlayers_1) { |
| 410 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 411 ASSERT_TRUE(media_session); |
| 412 DisableNativeBackend(media_session); |
| 413 |
| 414 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 415 new MockMediaSessionObserver); |
| 416 |
| 417 StartNewPlayer(media_session, media_session_observer.get(), |
| 418 MediaSession::Type::Content); |
| 419 StartNewPlayer(media_session, media_session_observer.get(), |
| 420 MediaSession::Type::Content); |
| 421 StartNewPlayer(media_session, media_session_observer.get(), |
| 422 MediaSession::Type::Content); |
| 423 |
| 424 EXPECT_EQ(0, media_session_observer->received_suspend_calls()); |
| 425 EXPECT_EQ(0, media_session_observer->received_resume_calls()); |
| 426 |
| 427 SuspendSession(media_session); |
| 428 EXPECT_EQ(3, media_session_observer->received_suspend_calls()); |
| 429 |
| 430 ResumeSession(media_session); |
| 431 EXPECT_EQ(3, media_session_observer->received_resume_calls()); |
| 432 |
| 433 media_session->RemovePlayers(media_session_observer.get()); |
| 434 } |
| 435 |
| 436 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 437 ResumeSuspendAreSentOnlyOncePerPlayers_2) { |
| 438 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 439 ASSERT_TRUE(media_session); |
| 440 DisableNativeBackend(media_session); |
| 441 |
| 442 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 443 new MockMediaSessionObserver); |
| 444 |
| 445 StartNewPlayer(media_session, media_session_observer.get(), |
| 446 MediaSession::Type::Content); |
| 447 StartNewPlayer(media_session, media_session_observer.get(), |
| 448 MediaSession::Type::Content); |
| 449 StartNewPlayer(media_session, media_session_observer.get(), |
| 450 MediaSession::Type::Content); |
| 451 |
| 452 // Adding the three players above again. |
| 453 EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 0, |
| 454 MediaSession::Type::Content)); |
| 455 EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 1, |
| 456 MediaSession::Type::Content)); |
| 457 EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 2, |
| 458 MediaSession::Type::Content)); |
| 459 |
| 460 EXPECT_EQ(0, media_session_observer->received_suspend_calls()); |
| 461 EXPECT_EQ(0, media_session_observer->received_resume_calls()); |
| 462 |
| 463 SuspendSession(media_session); |
| 464 EXPECT_EQ(3, media_session_observer->received_suspend_calls()); |
| 465 |
| 466 ResumeSession(media_session); |
| 467 EXPECT_EQ(3, media_session_observer->received_resume_calls()); |
| 468 |
| 469 media_session->RemovePlayers(media_session_observer.get()); |
| 470 } |
| 471 |
| 472 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
| 473 RemovingTheSamePlayerTwiceIsANoop) { |
| 474 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 475 ASSERT_TRUE(media_session); |
| 476 DisableNativeBackend(media_session); |
| 477 |
| 478 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 479 new MockMediaSessionObserver); |
| 480 |
| 481 StartNewPlayer(media_session, media_session_observer.get(), |
| 482 MediaSession::Type::Content); |
| 483 |
| 484 media_session->RemovePlayer(media_session_observer.get(), 0); |
| 485 media_session->RemovePlayer(media_session_observer.get(), 0); |
| 486 |
| 487 media_session->RemovePlayers(media_session_observer.get()); |
| 488 } |
| 489 |
| 490 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, MediaSessionType) { |
| 491 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); |
| 492 ASSERT_TRUE(media_session); |
| 493 DisableNativeBackend(media_session); |
| 494 |
| 495 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
| 496 new MockMediaSessionObserver); |
| 497 |
| 498 // Starting a player with a given type should set the session to that type. |
| 499 StartNewPlayer(media_session, media_session_observer.get(), |
| 500 MediaSession::Type::Transient); |
| 501 EXPECT_EQ(MediaSession::Type::Transient, GetSessionType(media_session)); |
| 502 |
| 503 // Adding a player of the same type should have no effect on the type. |
| 504 StartNewPlayer(media_session, media_session_observer.get(), |
| 505 MediaSession::Type::Transient); |
| 506 EXPECT_EQ(MediaSession::Type::Transient, GetSessionType(media_session)); |
| 507 |
| 508 // Adding a player of Content type should override the current type. |
| 509 StartNewPlayer(media_session, media_session_observer.get(), |
| 510 MediaSession::Type::Content); |
| 511 EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session)); |
| 512 |
| 513 // Adding a player of the Transient type should have no effect on the type. |
| 514 StartNewPlayer(media_session, media_session_observer.get(), |
| 515 MediaSession::Type::Transient); |
| 516 EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session)); |
| 517 |
| 518 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
| 519 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
| 520 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
| 521 EXPECT_TRUE(media_session_observer->IsPlaying(3)); |
| 522 |
| 523 SuspendSession(media_session); |
| 524 |
| 525 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
| 526 EXPECT_FALSE(media_session_observer->IsPlaying(1)); |
| 527 EXPECT_FALSE(media_session_observer->IsPlaying(2)); |
| 528 EXPECT_FALSE(media_session_observer->IsPlaying(3)); |
| 529 |
| 530 EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session)); |
| 531 |
| 532 ResumeSession(media_session); |
| 533 |
| 534 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
| 535 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
| 536 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
| 537 EXPECT_TRUE(media_session_observer->IsPlaying(3)); |
| 538 |
| 539 EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session)); |
| 540 |
| 541 media_session->RemovePlayers(media_session_observer.get()); |
| 542 } |
| 543 |
| 544 } // namespace content |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1110833004:
Move audio focus control from media/ to content/ and make it per WebContents. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master