content/browser/media/android/media_session_browsertest.cc

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