[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/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:
   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);
+
+  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 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(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(
       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()->show_counter());
+}
+
+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.