[Android] A prototype of the interactive media notification.

content/browser/media/android/media_session_browsertest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/media/android/media_session.h"
 
 #include <list>
 #include <vector>
 
 #include "content/browser/media/android/media_session_observer.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_delegate.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/shell/browser/shell.h"
 
-namespace content {
+using content::WebContents;
+using content::WebContentsDelegate;
+using content::MediaSession;
+using content::MediaSessionObserver;
+
+namespace {
 
 class MockMediaSessionObserver : public MediaSessionObserver {
  public:
   MockMediaSessionObserver()
       : received_resume_calls_(0),
         received_suspend_calls_(0) {
   }
 
   ~MockMediaSessionObserver() override = default;
 
   // Implements MediaSessionObserver.
   void OnSuspend(int player_id) override {
     DCHECK(player_id >= 0);
     DCHECK(players_.size() > static_cast<size_t>(player_id));
 
     ++received_suspend_calls_;
     players_[player_id] = false;
   }
+
   void OnResume(int player_id) override {
     DCHECK(player_id >= 0);
     DCHECK(players_.size() > static_cast<size_t>(player_id));
 
     ++received_resume_calls_;
     players_[player_id] = true;
   }
 
   int StartNewPlayer() {
     players_.push_back(true);
@@ skipping 20 matching lines @@
 
  private:
   // Basic representation of the players. The position in the vector is the
   // player_id. The value of the vector is the playing status.
   std::vector<bool> players_;
 
   int received_resume_calls_;
   int received_suspend_calls_;
 };
 
-class MediaSessionBrowserTest : public ContentBrowserTest  {
+class MockWebContentsDelegate : public WebContentsDelegate {
+ public:
+  explicit MockWebContentsDelegate(WebContents* web_contents)
+      : web_contents_(web_contents),
+        update_counter_(0) {
+  }
+
+  void UpdateMediaControls(WebContents* web_contents) override {
+    EXPECT_EQ(web_contents_, web_contents);
+    ++update_counter_;
+  }
+
+  int update_counter() const { return update_counter_; }
+
+ private:
+  WebContents* web_contents_;
+  int update_counter_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockWebContentsDelegate);
+};
+
+}  // namespace
+
+class MediaSessionBrowserTest : public content::ContentBrowserTest  {

[qinmin, 2015/06/24 19:10:20]

does this class now lose it namespace?

[whywhat, 2015/06/25 10:10:52]

could you please clarify the question? this class is not defined in the content
namespace, yes.

  protected:
   MediaSessionBrowserTest() = default;
 
-  void DisableNativeBackend(MediaSession* media_session) {
-    media_session->ResetJavaRefForTest();
+  void SetUpOnMainThread() override {
+    ContentBrowserTest::SetUpOnMainThread();
+
+    mock_web_contents_delegate_.reset(
+        new MockWebContentsDelegate(shell()->web_contents()));
+    previous_delegate_ = shell()->web_contents()->GetDelegate();
+    shell()->web_contents()->SetDelegate(mock_web_contents_delegate_.get());
+    media_session_ = MediaSession::Get(shell()->web_contents());
+    media_session_->ResetJavaRefForTest();
+    ASSERT_TRUE(media_session_);
   }
 
-  void StartNewPlayer(MediaSession* media_session,
-                      MockMediaSessionObserver* media_session_observer,
+  void TearDownOnMainThread() override {
+    media_session_->RemoveAllPlayersForTest();
+    media_session_ = nullptr;
+
+    shell()->web_contents()->SetDelegate(previous_delegate_);
+
+    ContentBrowserTest::TearDownOnMainThread();
+  }
+
+  void StartNewPlayer(MockMediaSessionObserver* media_session_observer,
                       MediaSession::Type type) {
-    bool result = media_session->AddPlayer(
-        media_session_observer,
-        media_session_observer->StartNewPlayer(),
-        type);
+    bool result = AddPlayer(
+        media_session_observer, media_session_observer->StartNewPlayer(), type);
     EXPECT_TRUE(result);
   }
 
-  void SuspendSession(MediaSession* media_session) {
-    media_session->OnSuspend(true);
+  bool AddPlayer(MockMediaSessionObserver* media_session_observer,
+                 int player_id,
+                 MediaSession::Type type) {
+    return media_session_->AddPlayer(media_session_observer, player_id, type);
   }
 
-  void ResumeSession(MediaSession* media_session) {
-    media_session->OnResume();
+  void RemovePlayer(
+      MockMediaSessionObserver* media_session_observer, int player_id) {
+    media_session_->RemovePlayer(media_session_observer, player_id);
   }
 
-  bool HasAudioFocus(MediaSession* media_session) {
-    return media_session->IsActiveForTest();
+  void RemovePlayers(
+      MockMediaSessionObserver* media_session_observer) {
+    media_session_->RemovePlayers(media_session_observer);
   }
 
-  MediaSession::Type GetSessionType(MediaSession* media_session) {
-    return media_session->audio_focus_type_for_test();
+  void SuspendSession(bool isTemporary) {
+    media_session_->OnSuspend(nullptr, nullptr, isTemporary);
   }
 
- private:
+  void ResumeSession() {
+    media_session_->OnResume(nullptr, nullptr);
+  }
+
+  bool HasAudioFocus() {
+    return media_session_->IsActiveForTest();
+  }
+
+  MediaSession::Type GetSessionType() {
+    return media_session_->audio_focus_type_for_test();
+  }
+
+  bool IsControllable() {
+    return media_session_->IsControllable();
+  }
+
+  bool IsPaused() {
+    return media_session_->IsPaused();
+  }
+
+  void ControlsPlay() {
+    media_session_->OnControlsResume();
+  }
+
+  void ControlsPause() {
+    media_session_->OnControlsPause();
+  }
+
+  const MockWebContentsDelegate* mock_web_contents_delegate() {
+    return mock_web_contents_delegate_.get();
+  }
+
+ protected:
+  scoped_ptr<MockWebContentsDelegate> mock_web_contents_delegate_;
+
+  MediaSession* media_session_;
+
+  WebContentsDelegate* previous_delegate_;
+
   DISALLOW_COPY_AND_ASSIGN(MediaSessionBrowserTest);
 };
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        PlayersFromSameObserverDoNotStopEachOtherInSameSession) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
   EXPECT_TRUE(media_session_observer->IsPlaying(0));
   EXPECT_TRUE(media_session_observer->IsPlaying(1));
   EXPECT_TRUE(media_session_observer->IsPlaying(2));
-
-  media_session->RemovePlayers(media_session_observer.get());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        PlayersFromManyObserverDoNotStopEachOtherInSameSession) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
   scoped_ptr<MockMediaSessionObserver> media_session_observer_1(
       new MockMediaSessionObserver);
   scoped_ptr<MockMediaSessionObserver> media_session_observer_2(
       new MockMediaSessionObserver);
   scoped_ptr<MockMediaSessionObserver> media_session_observer_3(
       new MockMediaSessionObserver);
 
-  StartNewPlayer(media_session, media_session_observer_1.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer_2.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer_3.get(),
-                 MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content);
+
+  StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer_3.get(), MediaSession::Type::Content);
 
   EXPECT_TRUE(media_session_observer_1->IsPlaying(0));
   EXPECT_TRUE(media_session_observer_2->IsPlaying(0));
   EXPECT_TRUE(media_session_observer_3->IsPlaying(0));
-
-  media_session->RemovePlayers(media_session_observer_1.get());
-  media_session->RemovePlayers(media_session_observer_2.get());
-  media_session->RemovePlayers(media_session_observer_3.get());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        SuspendedMediaSessionStopsPlayers) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
-  SuspendSession(media_session);
+  SuspendSession(true);
 
   EXPECT_FALSE(media_session_observer->IsPlaying(0));
   EXPECT_FALSE(media_session_observer->IsPlaying(1));
   EXPECT_FALSE(media_session_observer->IsPlaying(2));
-
-  media_session->RemovePlayers(media_session_observer.get());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        ResumedMediaSessionRestartsPlayers) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
-  SuspendSession(media_session);
-  ResumeSession(media_session);
+  SuspendSession(true);
+  ResumeSession();
 
   EXPECT_TRUE(media_session_observer->IsPlaying(0));
   EXPECT_TRUE(media_session_observer->IsPlaying(1));
   EXPECT_TRUE(media_session_observer->IsPlaying(2));
-
-  media_session->RemovePlayers(media_session_observer.get());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        StartedPlayerOnSuspendedSessionPlaysAlone) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
   EXPECT_TRUE(media_session_observer->IsPlaying(0));
 
-  SuspendSession(media_session);
+  SuspendSession(true);
 
   EXPECT_FALSE(media_session_observer->IsPlaying(0));
 
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
   EXPECT_FALSE(media_session_observer->IsPlaying(0));
   EXPECT_TRUE(media_session_observer->IsPlaying(1));
 
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
   EXPECT_FALSE(media_session_observer->IsPlaying(0));
   EXPECT_TRUE(media_session_observer->IsPlaying(1));
   EXPECT_TRUE(media_session_observer->IsPlaying(2));
-
-  media_session->RemovePlayers(media_session_observer.get());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, AudioFocusInitialState) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
-  EXPECT_FALSE(HasAudioFocus(media_session));
+  EXPECT_FALSE(HasAudioFocus());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, StartPlayerGivesFocus) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
-  EXPECT_TRUE(HasAudioFocus(media_session));
-
-  media_session->RemovePlayers(media_session_observer.get());
+  EXPECT_TRUE(HasAudioFocus());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, SuspendGivesAwayAudioFocus) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
-  SuspendSession(media_session);
+  SuspendSession(true);
 
-  EXPECT_FALSE(HasAudioFocus(media_session));
-
-  media_session->RemovePlayers(media_session_observer.get());
+  EXPECT_FALSE(HasAudioFocus());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumeGivesBackAudioFocus) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
-  SuspendSession(media_session);
-  ResumeSession(media_session);
+  SuspendSession(true);
+  ResumeSession();
 
-  EXPECT_TRUE(HasAudioFocus(media_session));
-
-  media_session->RemovePlayers(media_session_observer.get());
+  EXPECT_TRUE(HasAudioFocus());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
-                       RemovingLastPlayerDropsAudioFocus_1) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
+                       RemovingLastPlayerDropsAudioFocus) {
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
-  media_session->RemovePlayer(media_session_observer.get(), 0);
-  EXPECT_TRUE(HasAudioFocus(media_session));
-  media_session->RemovePlayer(media_session_observer.get(), 1);
-  EXPECT_TRUE(HasAudioFocus(media_session));
-  media_session->RemovePlayer(media_session_observer.get(), 2);
-  EXPECT_FALSE(HasAudioFocus(media_session));
+  RemovePlayer(media_session_observer.get(), 0);
+  EXPECT_TRUE(HasAudioFocus());
+  RemovePlayer(media_session_observer.get(), 1);
+  EXPECT_TRUE(HasAudioFocus());
+  RemovePlayer(media_session_observer.get(), 2);
+  EXPECT_FALSE(HasAudioFocus());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
-                       RemovingLastPlayerDropsAudioFocus_2) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
+                       RemovingLastPlayerFromManyObserversDropsAudioFocus) {
   scoped_ptr<MockMediaSessionObserver> media_session_observer_1(
       new MockMediaSessionObserver);
   scoped_ptr<MockMediaSessionObserver> media_session_observer_2(
       new MockMediaSessionObserver);
   scoped_ptr<MockMediaSessionObserver> media_session_observer_3(
       new MockMediaSessionObserver);
 
-  StartNewPlayer(media_session, media_session_observer_1.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer_2.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer_3.get(),
-                 MediaSession::Type::Content);
-
-  media_session->RemovePlayer(media_session_observer_1.get(), 0);
-  EXPECT_TRUE(HasAudioFocus(media_session));
-  media_session->RemovePlayer(media_session_observer_2.get(), 0);
-  EXPECT_TRUE(HasAudioFocus(media_session));
-  media_session->RemovePlayer(media_session_observer_3.get(), 0);
-  EXPECT_FALSE(HasAudioFocus(media_session));
-}
-
-IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
-                       RemovingLastPlayerDropsAudioFocus_3) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
+  StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer_3.get(), MediaSession::Type::Content);
+
+  RemovePlayer(media_session_observer_1.get(), 0);
+  EXPECT_TRUE(HasAudioFocus());
+  RemovePlayer(media_session_observer_2.get(), 0);
+  EXPECT_TRUE(HasAudioFocus());
+  RemovePlayer(media_session_observer_3.get(), 0);
+  EXPECT_FALSE(HasAudioFocus());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+                       RemovingAllPlayersFromObserversDropsAudioFocus) {
   scoped_ptr<MockMediaSessionObserver> media_session_observer_1(
       new MockMediaSessionObserver);
   scoped_ptr<MockMediaSessionObserver> media_session_observer_2(
       new MockMediaSessionObserver);
 
-  StartNewPlayer(media_session, media_session_observer_1.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer_1.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer_2.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer_2.get(),
-                 MediaSession::Type::Content);
-
-  media_session->RemovePlayers(media_session_observer_1.get());
-  EXPECT_TRUE(HasAudioFocus(media_session));
-  media_session->RemovePlayers(media_session_observer_2.get());
-  EXPECT_FALSE(HasAudioFocus(media_session));
+  StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content);
+
+  RemovePlayers(media_session_observer_1.get());
+  EXPECT_TRUE(HasAudioFocus());
+  RemovePlayers(media_session_observer_2.get());
+  EXPECT_FALSE(HasAudioFocus());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumePlayGivesAudioFocus) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
-  scoped_ptr<MockMediaSessionObserver> media_session_observer(
-      new MockMediaSessionObserver);
-
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
-
-  media_session->RemovePlayer(media_session_observer.get(), 0);
-  EXPECT_FALSE(HasAudioFocus(media_session));
-
-  EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 0,
-                                       MediaSession::Type::Content));
-  EXPECT_TRUE(HasAudioFocus(media_session));
-
-  media_session->RemovePlayers(media_session_observer.get());
-}
-
-IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
-                       ResumeSuspendAreSentOnlyOncePerPlayers_1) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
-  scoped_ptr<MockMediaSessionObserver> media_session_observer(
-      new MockMediaSessionObserver);
-
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+
+  RemovePlayer(media_session_observer.get(), 0);
+  EXPECT_FALSE(HasAudioFocus());
+
+  EXPECT_TRUE(AddPlayer(
+      media_session_observer.get(), 0, MediaSession::Type::Content));
+  EXPECT_TRUE(HasAudioFocus());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+                       ResumeSuspendAreSentOnlyOncePerPlayers) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
   EXPECT_EQ(0, media_session_observer->received_suspend_calls());
   EXPECT_EQ(0, media_session_observer->received_resume_calls());
 
-  SuspendSession(media_session);
+  SuspendSession(true);
   EXPECT_EQ(3, media_session_observer->received_suspend_calls());
 
-  ResumeSession(media_session);
+  ResumeSession();
   EXPECT_EQ(3, media_session_observer->received_resume_calls());
-
-  media_session->RemovePlayers(media_session_observer.get());
-}
-
-IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
-                       ResumeSuspendAreSentOnlyOncePerPlayers_2) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
-  scoped_ptr<MockMediaSessionObserver> media_session_observer(
-      new MockMediaSessionObserver);
-
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+                       ResumeSuspendAreSentOnlyOncePerPlayersAddedTwice) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
   // Adding the three players above again.
-  EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 0,
-                                       MediaSession::Type::Content));
-  EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 1,
-                                       MediaSession::Type::Content));
-  EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 2,
-                                       MediaSession::Type::Content));
+  EXPECT_TRUE(AddPlayer(
+      media_session_observer.get(), 0, MediaSession::Type::Content));
+  EXPECT_TRUE(AddPlayer(
+      media_session_observer.get(), 1, MediaSession::Type::Content));
+  EXPECT_TRUE(AddPlayer(
+      media_session_observer.get(), 2, MediaSession::Type::Content));
 
   EXPECT_EQ(0, media_session_observer->received_suspend_calls());
   EXPECT_EQ(0, media_session_observer->received_resume_calls());
 
-  SuspendSession(media_session);
+  SuspendSession(true);
   EXPECT_EQ(3, media_session_observer->received_suspend_calls());
 
-  ResumeSession(media_session);
+  ResumeSession();
   EXPECT_EQ(3, media_session_observer->received_resume_calls());
-
-  media_session->RemovePlayers(media_session_observer.get());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        RemovingTheSamePlayerTwiceIsANoop) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
-  scoped_ptr<MockMediaSessionObserver> media_session_observer(
-      new MockMediaSessionObserver);
-
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
-
-  media_session->RemovePlayer(media_session_observer.get(), 0);
-  media_session->RemovePlayer(media_session_observer.get(), 0);
-
-  media_session->RemovePlayers(media_session_observer.get());
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+
+  RemovePlayer(media_session_observer.get(), 0);
+  RemovePlayer(media_session_observer.get(), 0);
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, MediaSessionType) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   // Starting a player with a given type should set the session to that type.
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Transient);
-  EXPECT_EQ(MediaSession::Type::Transient, GetSessionType(media_session));
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient);
+  EXPECT_EQ(MediaSession::Type::Transient, GetSessionType());
 
   // Adding a player of the same type should have no effect on the type.
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Transient);
-  EXPECT_EQ(MediaSession::Type::Transient, GetSessionType(media_session));
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient);
+  EXPECT_EQ(MediaSession::Type::Transient, GetSessionType());
 
   // Adding a player of Content type should override the current type.
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Content);
-  EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session));
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  EXPECT_EQ(MediaSession::Type::Content, GetSessionType());
 
   // Adding a player of the Transient type should have no effect on the type.
-  StartNewPlayer(media_session, media_session_observer.get(),
-                 MediaSession::Type::Transient);
-  EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session));
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient);
+  EXPECT_EQ(MediaSession::Type::Content, GetSessionType());
 
   EXPECT_TRUE(media_session_observer->IsPlaying(0));
   EXPECT_TRUE(media_session_observer->IsPlaying(1));
   EXPECT_TRUE(media_session_observer->IsPlaying(2));
   EXPECT_TRUE(media_session_observer->IsPlaying(3));
 
-  SuspendSession(media_session);
+  SuspendSession(true);
 
   EXPECT_FALSE(media_session_observer->IsPlaying(0));
   EXPECT_FALSE(media_session_observer->IsPlaying(1));
   EXPECT_FALSE(media_session_observer->IsPlaying(2));
   EXPECT_FALSE(media_session_observer->IsPlaying(3));
 
-  EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session));
-
-  ResumeSession(media_session);
+  EXPECT_EQ(MediaSession::Type::Content, GetSessionType());
+
+  ResumeSession();
 
   EXPECT_TRUE(media_session_observer->IsPlaying(0));
   EXPECT_TRUE(media_session_observer->IsPlaying(1));
   EXPECT_TRUE(media_session_observer->IsPlaying(2));
   EXPECT_TRUE(media_session_observer->IsPlaying(3));
 
-  EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session));
-
-  media_session->RemovePlayers(media_session_observer.get());
-}
-
-}  // namespace content
+  EXPECT_EQ(MediaSession::Type::Content, GetSessionType());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsShowForContent) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  // Starting a player with a content type should show the media controls.
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+
+  EXPECT_EQ(1, mock_web_contents_delegate()->update_counter());
+  EXPECT_TRUE(IsControllable());
+  EXPECT_FALSE(IsPaused());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsNoShowForTransient) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  // Starting a player with a transient type should not show the media controls.
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient);
+
+  EXPECT_EQ(1, mock_web_contents_delegate()->update_counter());
+  EXPECT_FALSE(IsControllable());
+  EXPECT_TRUE(IsPaused());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsHideWhenStopped) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+
+  RemovePlayers(media_session_observer.get());
+
+  EXPECT_EQ(2, mock_web_contents_delegate()->update_counter());
+  EXPECT_FALSE(IsControllable());
+  EXPECT_TRUE(IsPaused());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsShownAcceptTransient) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+
+  // Transient player join the session without affecting the controls.
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient);
+
+  EXPECT_EQ(1, mock_web_contents_delegate()->update_counter());
+  EXPECT_TRUE(IsControllable());
+  EXPECT_FALSE(IsPaused());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+    ControlsShownAfterContentAdded) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient);
+
+  // The controls are shown when the content player is added.
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+
+  EXPECT_EQ(2, mock_web_contents_delegate()->update_counter());
+  EXPECT_TRUE(IsControllable());
+  EXPECT_FALSE(IsPaused());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+    ControlsStayIfOnlyOnePlayerHasBeenPaused) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient);
+
+  // Removing only content player doesn't hide the controls since the session
+  // is still active.
+  RemovePlayer(media_session_observer.get(), 0);
+
+  EXPECT_EQ(1, mock_web_contents_delegate()->update_counter());
+  EXPECT_TRUE(IsControllable());
+  EXPECT_FALSE(IsPaused());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+    ControlsHideWhenTheLastPlayerIsStopped) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+
+  RemovePlayer(media_session_observer.get(), 0);
+
+  EXPECT_EQ(1, mock_web_contents_delegate()->update_counter());
+  EXPECT_TRUE(IsControllable());
+  EXPECT_FALSE(IsPaused());
+
+  RemovePlayer(media_session_observer.get(), 1);
+
+  EXPECT_EQ(2, mock_web_contents_delegate()->update_counter());
+  EXPECT_FALSE(IsControllable());
+  EXPECT_TRUE(IsPaused());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+    ControlsHideWhenAllThePlayersAreRemoved) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+
+  RemovePlayers(media_session_observer.get());
+
+  EXPECT_EQ(2, mock_web_contents_delegate()->update_counter());
+  EXPECT_FALSE(IsControllable());
+  EXPECT_TRUE(IsPaused());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+    SuspendTemporaryUpdatesControls) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+
+  SuspendSession(true);
+
+  EXPECT_EQ(2, mock_web_contents_delegate()->update_counter());
+  EXPECT_TRUE(IsControllable());
+  EXPECT_TRUE(IsPaused());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsUpdatedWhenResumed) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  SuspendSession(true);
+  ResumeSession();
+
+  EXPECT_EQ(3, mock_web_contents_delegate()->update_counter());
+  EXPECT_TRUE(IsControllable());
+  EXPECT_FALSE(IsPaused());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+    ControlsHideWhenSessionSuspendedPermanently) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+
+  SuspendSession(false);
+
+  EXPECT_EQ(2, mock_web_contents_delegate()->update_counter());
+  EXPECT_FALSE(IsControllable());
+  EXPECT_TRUE(IsPaused());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+    ControlsHideWhenSessionChangesFromContentToTransient) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  SuspendSession(true);
+
+  // This should reset the session and change it to a transient, so
+  // hide the controls.
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient);
+
+  EXPECT_EQ(3, mock_web_contents_delegate()->update_counter());
+  EXPECT_FALSE(IsControllable());
+  EXPECT_TRUE(IsPaused());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+    ControlsUpdatedWhenNewPlayerResetsSession) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  SuspendSession(true);
+
+  // This should reset the session and update the controls.
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+
+  EXPECT_EQ(3, mock_web_contents_delegate()->update_counter());
+  EXPECT_TRUE(IsControllable());
+  EXPECT_TRUE(IsPaused());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+    ControlsResumedWhenPlayerIsResumed) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  SuspendSession(true);
+
+  // This should resume the session and update the controls.
+  AddPlayer(media_session_observer.get(), 0, MediaSession::Type::Content);
+
+  EXPECT_EQ(3, mock_web_contents_delegate()->update_counter());
+  EXPECT_TRUE(IsControllable());
+  EXPECT_TRUE(IsPaused());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+    ControlsNotUpdatedDueToControlsPlayAction) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  ControlsPause();
+
+  EXPECT_EQ(1, mock_web_contents_delegate()->update_counter());
+  EXPECT_TRUE(IsControllable());
+  EXPECT_TRUE(IsPaused());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+    ControlsNotUpdatedDueToControlsPauseAction) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  ControlsPause();
+  ControlsPlay();
+
+  EXPECT_EQ(1, mock_web_contents_delegate()->update_counter());
+  EXPECT_TRUE(IsControllable());
+  EXPECT_FALSE(IsPaused());
+}