[MediaSession, Android] Adding visibility tests for MediaSession

content/browser/media/session/media_session_visibility_browsertest_base.cc

Index: content/browser/media/session/media_session_visibility_browsertest_base.cc
diff --git a/content/browser/media/session/media_session_visibility_browsertest_base.cc b/content/browser/media/session/media_session_visibility_browsertest_base.cc
new file mode 100644
index 0000000000000000000000000000000000000000..38ec9692afd17bb7fd0be0ba8124114630c64512
--- /dev/null
+++ b/content/browser/media/session/media_session_visibility_browsertest_base.cc
@@ -0,0 +1,177 @@
+// Copyright 2016 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/session/media_session_visibility_browsertest_base.h"
+
+#include "base/command_line.h"
+#include "base/timer/elapsed_timer.h"
+#include "content/browser/media/session/media_session.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/common/content_switches.h"
+#include "content/public/test/content_browser_test_utils.h"
+#include "content/public/test/test_navigation_observer.h"
+#include "content/shell/browser/shell.h"
+#include "media/base/media_switches.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+static const char kStartPlayerScript[] =
+    "document.getElementById('long-video').play()";
+static const char kPausePlayerScript[] =
+    "document.getElementById('long-video').pause()";
+
+static const int kWaitTimeSeconds = 5;
+static const int kWaitIntervalMilliseconds = 50;
+}
+
+using content::MediaSessionVisibilityBrowserTestBase;
+
+void MediaSessionVisibilityBrowserTestBase::SetUpOnMainThread() {
+  ContentBrowserTest::SetUpOnMainThread();
+  web_contents_ = shell()->web_contents();
+  media_session_ = MediaSession::Get(web_contents_);
+}
+
+void MediaSessionVisibilityBrowserTestBase::SetUpCommandLine(
+    base::CommandLine* command_line) {
+  command_line->AppendSwitch(
+      switches::kDisableGestureRequirementForMediaPlayback);
+#if !defined(OS_ANDROID)
+  command_line->AppendSwitch(
+      switches::kEnableDefaultMediaSession);
+#endif  // !defined(OS_ANDROID)
+}
+
+void MediaSessionVisibilityBrowserTestBase::LoadTestPage() {
+  TestNavigationObserver navigation_observer(shell()->web_contents(), 1);
+  shell()->LoadURL(GetTestUrl("android/media", "media-session.html"));
+  navigation_observer.Wait();
+}
+
+void MediaSessionVisibilityBrowserTestBase::RunScript(std::string script) {
+  content::ExecuteScriptAndGetValue(
+      web_contents_->GetMainFrame(), script);
+}
+
+// TODO(zqzhang): This method is shared with
+// MediaVisibilityTests. Move it into a general place.
+bool MediaSessionVisibilityBrowserTestBase::ConditionalWait(

[DaleCurtis, 2016/03/24 20:21:25]

You shouldn't need to manually handle timeouts, this should be handled by the
browsertest harness itself.

I also don't know if this is the right way to go about this. What about having a
new method on MediaSession::SetOnAudioStateChangedCallbackForTesting(). This
callback would be executed when audio_focus_state_ changed. This would let you
get rid of all the waits in this file I think.

[Zhiqiang Zhang (Slow), 2016/03/31 13:00:19]

Done.

+    base::TimeDelta timeout,
+    base::TimeDelta interval,
+    const base::Callback<bool(void)>& callback) {
+  base::ElapsedTimer timer;
+  do {
+    if (callback.Run())
+      return true;
+
+    base::RunLoop run_loop;
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE, run_loop.QuitClosure(), interval);
+    run_loop.Run();
+  } while (timer.Elapsed() < timeout);
+
+  return false;
+}
+
+void MediaSessionVisibilityBrowserTestBase::Wait(base::TimeDelta timeout) {
+  base::RunLoop run_loop;
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE, run_loop.QuitClosure(), timeout);
+  run_loop.Run();
+}
+
+bool MediaSessionVisibilityBrowserTestBase::IsMediaSessionActive() {
+  return media_session_->audio_focus_state_ == MediaSession::State::ACTIVE;
+}
+
+bool MediaSessionVisibilityBrowserTestBase::IsMediaSessionSuspended() {
+  return media_session_->audio_focus_state_ == MediaSession::State::SUSPENDED;
+}
+
+bool MediaSessionVisibilityBrowserTestBase::IsMediaSessionInactive() {
+  return media_session_->audio_focus_state_ == MediaSession::State::INACTIVE;
+}
+
+bool MediaSessionVisibilityBrowserTestBase::WaitForMediaSessionActive() {
+  return ConditionalWait(
+      base::TimeDelta::FromSeconds(kWaitTimeSeconds),
+      base::TimeDelta::FromMilliseconds(kWaitIntervalMilliseconds),
+      base::Bind(
+          &MediaSessionVisibilityBrowserTestBase::IsMediaSessionActive,
+          base::Unretained(this)));
+}
+
+bool MediaSessionVisibilityBrowserTestBase::WaitForMediaSessionSuspended() {
+  return ConditionalWait(
+      base::TimeDelta::FromSeconds(kWaitTimeSeconds),
+      base::TimeDelta::FromMilliseconds(kWaitIntervalMilliseconds),
+      base::Bind(
+          &MediaSessionVisibilityBrowserTestBase::IsMediaSessionSuspended,
+          base::Unretained(this)));
+}
+
+bool MediaSessionVisibilityBrowserTestBase::WaitForMediaSessionInactive() {
+  return ConditionalWait(
+      base::TimeDelta::FromSeconds(kWaitTimeSeconds),
+      base::TimeDelta::FromMilliseconds(kWaitIntervalMilliseconds),
+      base::Bind(
+          &MediaSessionVisibilityBrowserTestBase::IsMediaSessionInactive,
+          base::Unretained(this)));
+}
+
+void MediaSessionVisibilityBrowserTestBase
+::TestSessionInactiveWhenHiddenAfterContentPause() {
+  LoadTestPage();
+
+  RunScript(kStartPlayerScript);
+  ASSERT_TRUE(WaitForMediaSessionActive());
+
+  RunScript(kPausePlayerScript);
+  ASSERT_TRUE(WaitForMediaSessionSuspended());
+
+  web_contents_->WasHidden();
+  ASSERT_TRUE(WaitForMediaSessionInactive());
+}
+
+void MediaSessionVisibilityBrowserTestBase
+::TestSessionInactiveWhenHiddenWhilePlaying() {
+  LoadTestPage();
+
+  RunScript(kStartPlayerScript);
+  ASSERT_TRUE(WaitForMediaSessionActive());
+
+  web_contents_->WasHidden();
+  ASSERT_TRUE(WaitForMediaSessionInactive());
+}
+
+void MediaSessionVisibilityBrowserTestBase
+::TestSessionSuspendedWhenHiddenAfterContentPause() {
+  LoadTestPage();
+
+  RunScript(kStartPlayerScript);
+  ASSERT_TRUE(WaitForMediaSessionActive());
+
+  RunScript(kPausePlayerScript);
+  ASSERT_TRUE(WaitForMediaSessionSuspended());
+
+  // Wait for 1 second and check the MediaSession state.
+  // No better solution till now.
+  web_contents_->WasHidden();
+  Wait(base::TimeDelta::FromSeconds(1));
+  ASSERT_TRUE(IsMediaSessionSuspended());
+}
+
+void MediaSessionVisibilityBrowserTestBase
+::TestSessionActiveWhenHiddenWhilePlaying() {
+  LoadTestPage();
+
+  RunScript(kStartPlayerScript);
+  ASSERT_TRUE(WaitForMediaSessionActive());
+
+  // Wait for 1 second and check the MediaSession state.
+  // No better solution till now.
+  web_contents_->WasHidden();
+  Wait(base::TimeDelta::FromSeconds(1));
+  ASSERT_TRUE(IsMediaSessionActive());
+}