[Android] A prototype of the interactive media notification.

content/browser/media/android/media_session_browsertest.cc

Index: content/browser/media/android/media_session_browsertest.cc
diff --git a/content/browser/media/android/media_session_browsertest.cc b/content/browser/media/android/media_session_browsertest.cc
index 1fc812189feb70e3189b7700a763a87e55d1a808..f2dd46550b84327f1689647e303429ac84bea446 100644
--- a/content/browser/media/android/media_session_browsertest.cc
+++ b/content/browser/media/android/media_session_browsertest.cc
@@ -8,10 +8,18 @@
 #include <vector>
 
 #include "content/browser/media/android/media_session_observer.h"
+#include "content/common/content_export.h"

[mlamouri (slow - plz ping), 2015/06/24 16:15:02]

Why do you need that?

[whywhat, 2015/06/24 18:36:15]

Left over from the experimentation I did with the mock WebContentsDelegate.
Removed.

+#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 {

[mlamouri (slow - plz ping), 2015/06/24 16:15:02]

Maybe you could keep the namespace content and have an anonymous namespace
inside it?

[whywhat, 2015/06/24 18:36:15]

I don't know I'd rather not :)

+using content::WebContents;
+using content::WebContentsDelegate;
+using content::MediaSession;
+using content::MediaSessionObserver;
+
+namespace {
 
 class MockMediaSessionObserver : public MediaSessionObserver {
  public:
@@ -30,6 +38,7 @@ class MockMediaSessionObserver : public MediaSessionObserver {
     ++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));
@@ -70,73 +79,145 @@ class MockMediaSessionObserver : public MediaSessionObserver {
   int received_suspend_calls_;
 };
 
-class MediaSessionBrowserTest : public ContentBrowserTest  {
+class MockWebContentsDelegate : public WebContentsDelegate {
+ public:
+  explicit MockWebContentsDelegate(WebContents* web_contents);
+
+  void ShowMediaControls(WebContents* web_contents) override;
+
+  void HideMediaControls(WebContents* web_contents) override;

[mlamouri (slow - plz ping), 2015/06/24 16:15:02]

I guess these will need to change slightly.

[whywhat, 2015/06/24 18:36:15]

Indeed.

+
+  int show_counter() const;
+  int hide_counter() const;
+
+ private:
+  WebContents* web_contents_;
+  int show_counter_;
+  int hide_counter_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockWebContentsDelegate);
+};
+
+MockWebContentsDelegate::MockWebContentsDelegate(WebContents* web_contents)
+    : web_contents_(web_contents),
+      show_counter_(0),
+      hide_counter_(0) {
+}
+
+void MockWebContentsDelegate::ShowMediaControls(WebContents* web_contents) {
+  EXPECT_EQ(web_contents_, web_contents);
+  ++show_counter_;
+}
+
+void MockWebContentsDelegate::HideMediaControls(WebContents* web_contents) {
+  EXPECT_EQ(web_contents_, web_contents);
+  ++hide_counter_;
+}
+
+int MockWebContentsDelegate::show_counter() const {
+  return show_counter_;
+}
+
+int MockWebContentsDelegate::hide_counter() const {
+  return hide_counter_;
+}
+
+}  // namespace
+
+class MediaSessionBrowserTest : public content::ContentBrowserTest  {
  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();

[mlamouri (slow - plz ping), 2015/06/24 16:15:02]

Do you really need to save it? Isn't the WebContents killed when we are done
with the test anyway?

[whywhat, 2015/06/24 18:36:15]

Have no idea, better safe than sorry?

+    shell()->web_contents()->SetDelegate(mock_web_contents_delegate_.get());
+    media_session_ = MediaSession::Get(shell()->web_contents());
+    media_session_->ResetJavaRefForTest();
+    ASSERT_TRUE(media_session_);
+  }
+
+  void TearDownOnMainThread() override {
+    media_session_->RemoveAllPlayersForTest();
+    media_session_ = nullptr;
+
+    shell()->web_contents()->SetDelegate(previous_delegate_);
+
+    ContentBrowserTest::TearDownOnMainThread();
   }
 
-  void StartNewPlayer(MediaSession* media_session,
-                      MockMediaSessionObserver* media_session_observer,
+  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(NULL, NULL, isTemporary);

[mlamouri (slow - plz ping), 2015/06/24 16:15:02]

s/NULL/nullptr/g

[whywhat, 2015/06/24 18:36:16]

Done.

   }
 
- private:
+  void ResumeSession() {
+    media_session_->OnResume(NULL, NULL);

[mlamouri (slow - plz ping), 2015/06/24 16:15:02]

nit: s/NULL/nullptr/g

[whywhat, 2015/06/24 18:36:15]

Done.

+  }
+
+  bool HasAudioFocus() {
+    return media_session_->IsActiveForTest();
+  }
+
+  MediaSession::Type GetSessionType() {
+    return media_session_->audio_focus_type_for_test();
+  }
+
+  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(
@@ -144,198 +225,129 @@ IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
   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);
-
-  EXPECT_TRUE(HasAudioFocus(media_session));
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
-  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);
-
-  SuspendSession(media_session);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
-  EXPECT_FALSE(HasAudioFocus(media_session));
+  SuspendSession(true);
 
-  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(
@@ -343,202 +355,322 @@ IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
   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);
 
-  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));
+  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,
-                       RemovingLastPlayerDropsAudioFocus_3) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
+                       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);
+  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);
 
-  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));
+  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);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
-  media_session->RemovePlayer(media_session_observer.get(), 0);
-  EXPECT_FALSE(HasAudioFocus(media_session));
+  RemovePlayer(media_session_observer.get(), 0);
+  EXPECT_FALSE(HasAudioFocus());
 
-  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());
+  EXPECT_TRUE(AddPlayer(
+      media_session_observer.get(), 0, MediaSession::Type::Content));
+  EXPECT_TRUE(HasAudioFocus());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
-                       ResumeSuspendAreSentOnlyOncePerPlayers_1) {
-  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
-  ASSERT_TRUE(media_session);
-  DisableNativeBackend(media_session);
-
+                       ResumeSuspendAreSentOnlyOncePerPlayers) {
   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_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);
-
+                       ResumeSuspendAreSentOnlyOncePerPlayersAddedTwice) {
   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);
 
   // 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);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
-  media_session->RemovePlayers(media_session_observer.get());
+  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));
+  EXPECT_EQ(MediaSession::Type::Content, GetSessionType());
 
-  ResumeSession(media_session);
+  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));
+  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);
 
-  media_session->RemovePlayers(media_session_observer.get());
+  EXPECT_EQ(1, mock_web_contents_delegate()->show_counter());
 }
 
-}  // namespace content
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsNoShowForTransient) {
+  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::Transient);
+
+  EXPECT_EQ(0, mock_web_contents_delegate()->show_counter());
+}
+
+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(1, mock_web_contents_delegate()->hide_counter());
+}
+
+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()->show_counter());
+  EXPECT_EQ(0, mock_web_contents_delegate()->hide_counter());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+    ControlsShownAfterContentAdded) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient);
+
+  EXPECT_EQ(0, mock_web_contents_delegate()->show_counter());
+
+  // The controls are shown when the content player is added.
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+
+  EXPECT_EQ(1, mock_web_contents_delegate()->show_counter());
+}
+
+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(0, mock_web_contents_delegate()->hide_counter());
+}
+
+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(0, mock_web_contents_delegate()->hide_counter());
+
+  RemovePlayer(media_session_observer.get(), 1);
+
+  EXPECT_EQ(1, mock_web_contents_delegate()->hide_counter());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+    ControlsHideWhenTheAllPlayersAreRemoved) {

[mlamouri (slow - plz ping), 2015/06/24 16:15:02]

nit: ControlsHideWhenAllThePlayersAreRemoved

[whywhat, 2015/06/24 18:36:15]

Done.

+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+
+  EXPECT_EQ(0, mock_web_contents_delegate()->hide_counter());
+
+  RemovePlayers(media_session_observer.get());
+
+  EXPECT_EQ(1, mock_web_contents_delegate()->hide_counter());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+    SuspendTemporaryUpdatesControls) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
+
+  EXPECT_EQ(1, mock_web_contents_delegate()->show_counter());
+
+  SuspendSession(true);
+
+  EXPECT_EQ(2, mock_web_contents_delegate()->show_counter());
+  // Temporary suspend doesn't hide controls.
+  EXPECT_EQ(0, mock_web_contents_delegate()->hide_counter());
+}
+
+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()->show_counter());
+}
+
+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(1, mock_web_contents_delegate()->hide_counter());
+}
+
+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(2, mock_web_contents_delegate()->show_counter());
+  EXPECT_EQ(1, mock_web_contents_delegate()->hide_counter());
+}
+
+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()->show_counter());
+}

[mlamouri (slow - plz ping), 2015/06/24 16:15:02]

Can you add a test that call AddPlayer() on an already added player that was
paused (ie. it resumes the player) to check that the controls are properly
resumed.

Could you also check the behaviour when OnControlsPause() and OnControlsResume()
are called? Check that it doesn't try to send messages back to the controls.

It might be good to test ::IsPaused() and ::IsControllable() too.

[whywhat, 2015/06/24 18:36:15]

Done.