Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(754)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: media/blink/webmediaplayer_impl_unittest.cc

Issue 2490783002: Refactor WebMediaPlayerDelegate interface. (Closed)
Patch Set: Unit tests found a real bug! Created 3 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « media/blink/webmediaplayer_impl.cc ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: media/blink/webmediaplayer_impl_unittest.cc
diff --git a/media/blink/webmediaplayer_impl_unittest.cc b/media/blink/webmediaplayer_impl_unittest.cc
index a58b32bd60142d5a9894e1674673d53f8673fade..b0fbb4087e32dc2ff074a1cbf3f1748fedebe135 100644
--- a/media/blink/webmediaplayer_impl_unittest.cc
+++ b/media/blink/webmediaplayer_impl_unittest.cc
@@ -111,13 +111,75 @@ class MockWebMediaPlayerDelegate
~MockWebMediaPlayerDelegate() = default;
// WebMediaPlayerDelegate implementation.
- MOCK_METHOD1(AddObserver, int(Observer*));
- MOCK_METHOD1(RemoveObserver, void(int));
- MOCK_METHOD5(DidPlay, void(int, bool, bool, bool, MediaContentType));
- MOCK_METHOD2(DidPause, void(int, bool));
+ int AddObserver(Observer* observer) override {
+ DCHECK_EQ(nullptr, observer_);
+ observer_ = observer;
+ return player_id_;
+ }
+
+ void RemoveObserver(int player_id) override {
+ DCHECK_EQ(player_id_, player_id);
+ observer_ = nullptr;
+ }
+
+ MOCK_METHOD4(DidPlay, void(int, bool, bool, MediaContentType));
+ MOCK_METHOD1(DidPause, void(int));
MOCK_METHOD1(PlayerGone, void(int));
- MOCK_METHOD0(IsHidden, bool());
- MOCK_METHOD0(IsPlayingBackgroundVideo, bool());
+ MOCK_METHOD0(IsBackgroundVideoPlaybackUnlocked, bool());
+
+ void SetIdle(int player_id, bool is_idle) override {
+ DCHECK_EQ(player_id_, player_id);
+ is_idle_ = is_idle;
+ is_stale_ &= is_idle;
+ }
+
+ bool IsIdle(int player_id) override {
+ DCHECK_EQ(player_id_, player_id);
+ return is_idle_;
+ }
+
+ void ClearStaleFlag(int player_id) override {
+ DCHECK_EQ(player_id_, player_id);
+ is_stale_ = false;
+ }
+
+ bool IsStale(int player_id) override {
+ DCHECK_EQ(player_id_, player_id);
+ return is_stale_;
+ }
+
+ bool IsFrameHidden() override { return is_hidden_; }
+
+ bool IsFrameClosed() override { return is_closed_; }
+
+ void SetIdleForTesting(bool is_idle) { is_idle_ = is_idle; }
+
+ void SetStaleForTesting(bool is_stale) {
+ is_idle_ |= is_stale;
+ is_stale_ = is_stale;
+ }
+
+ // Returns true if the player does in fact expire.
+ bool ExpireForTesting() {
+ if (is_idle_ && !is_stale_) {
+ is_stale_ = true;
+ observer_->OnIdleTimeout();
+ }
+
+ return is_stale_;
+ }
+
+ void SetFrameHiddenForTesting(bool is_hidden) { is_hidden_ = is_hidden; }
+
+ void SetFrameClosedForTesting(bool is_closed) { is_closed_ = is_closed; }
+
+ private:
+ Observer* observer_ = nullptr;
+ int player_id_ = 1234;
+ bool is_idle_ = false;
+ bool is_stale_ = false;
+ bool is_hidden_ = false;
+ bool is_closed_ = false;
};
class WebMediaPlayerImplTest : public testing::Test {
@@ -189,74 +251,33 @@ class WebMediaPlayerImplTest : public testing::Test {
}
WebMediaPlayerImpl::PlayState ComputePlayState() {
- wmpi_->is_idle_ = false;
- wmpi_->must_suspend_ = false;
return wmpi_->UpdatePlayState_ComputePlayState(false, false, false, false);
}
- WebMediaPlayerImpl::PlayState ComputePlayStateSuspended() {
- wmpi_->is_idle_ = false;
- wmpi_->must_suspend_ = false;
- return wmpi_->UpdatePlayState_ComputePlayState(false, false, true, false);
- }
-
- WebMediaPlayerImpl::PlayState ComputeBackgroundedPlayState() {
- wmpi_->is_idle_ = false;
- wmpi_->must_suspend_ = false;
+ WebMediaPlayerImpl::PlayState ComputePlayState_FrameHidden() {
return wmpi_->UpdatePlayState_ComputePlayState(false, false, false, true);
}
- WebMediaPlayerImpl::PlayState ComputeIdlePlayState() {
- wmpi_->is_idle_ = true;
- wmpi_->must_suspend_ = false;
- return wmpi_->UpdatePlayState_ComputePlayState(false, false, false, false);
- }
-
- WebMediaPlayerImpl::PlayState ComputeIdleSuspendedPlayState() {
- wmpi_->is_idle_ = true;
- wmpi_->must_suspend_ = false;
+ WebMediaPlayerImpl::PlayState ComputePlayState_Suspended() {
return wmpi_->UpdatePlayState_ComputePlayState(false, false, true, false);
}
- WebMediaPlayerImpl::PlayState ComputeMustSuspendPlayState() {
- wmpi_->is_idle_ = false;
- wmpi_->must_suspend_ = true;
- return wmpi_->UpdatePlayState_ComputePlayState(false, false, false, false);
+ WebMediaPlayerImpl::PlayState ComputePlayState_Remote() {
+ return wmpi_->UpdatePlayState_ComputePlayState(true, false, false, false);
}
- WebMediaPlayerImpl::PlayState ComputeStreamingPlayState(bool must_suspend) {
- wmpi_->is_idle_ = true;
- wmpi_->must_suspend_ = must_suspend;
+ WebMediaPlayerImpl::PlayState ComputePlayState_BackgroundedStreaming() {
return wmpi_->UpdatePlayState_ComputePlayState(false, true, false, true);
}
- void SetDelegateState(WebMediaPlayerImpl::DelegateState state) {
- wmpi_->SetDelegateState(state);
- }
-
bool IsSuspended() { return wmpi_->pipeline_controller_.IsSuspended(); }
void AddBufferedRanges() {
wmpi_->buffered_data_source_host_.AddBufferedByteRange(0, 1);
}
- void SetupForResumingBackgroundVideo() {
-#if !defined(OS_ANDROID)
- // Need to enable media suspend to test resuming background videos.
- base::CommandLine::ForCurrentProcess()->AppendSwitch(
- switches::kEnableMediaSuspend);
-#endif // !defined(OS_ANDROID)
- scoped_feature_list_.InitAndEnableFeature(kResumeBackgroundVideo);
- }
-
- void SetBackgroundVideoOptimization(bool enable) {
- if (enable) {
- scoped_feature_list_.InitAndEnableFeature(
- kBackgroundVideoTrackOptimization);
- } else {
- scoped_feature_list_.InitAndDisableFeature(
- kBackgroundVideoTrackOptimization);
- }
+ void SetDelegateState(WebMediaPlayerImpl::DelegateState state) {
+ wmpi_->SetDelegateState(state, false);
}
bool ShouldDisableVideoWhenHidden() const {
@@ -296,19 +317,17 @@ class WebMediaPlayerImplTest : public testing::Test {
// The WebMediaPlayerImpl instance under test.
std::unique_ptr<WebMediaPlayerImpl> wmpi_;
- private:
- base::test::ScopedFeatureList scoped_feature_list_;
-
DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImplTest);
};
TEST_F(WebMediaPlayerImplTest, ConstructAndDestroy) {
InitializeWebMediaPlayerImpl();
+ EXPECT_FALSE(IsSuspended());
}
TEST_F(WebMediaPlayerImplTest, IdleSuspendIsEnabledBeforeLoadingBegins) {
InitializeWebMediaPlayerImpl();
- wmpi_->OnSuspendRequested(false);
+ EXPECT_TRUE(delegate_.ExpireForTesting());
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(IsSuspended());
}
@@ -323,7 +342,7 @@ TEST_F(WebMediaPlayerImplTest,
wmpi_->didLoadingProgress();
// Advance less than the loading timeout.
clock->Advance(base::TimeDelta::FromSeconds(1));
- wmpi_->OnSuspendRequested(false);
+ EXPECT_FALSE(delegate_.ExpireForTesting());
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(IsSuspended());
}
@@ -337,344 +356,287 @@ TEST_F(WebMediaPlayerImplTest, IdleSuspendIsEnabledIfLoadingHasStalled) {
wmpi_->didLoadingProgress();
// Advance more than the loading timeout.
clock->Advance(base::TimeDelta::FromSeconds(4));
- wmpi_->OnSuspendRequested(false);
+ EXPECT_TRUE(delegate_.ExpireForTesting());
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(IsSuspended());
}
TEST_F(WebMediaPlayerImplTest, DidLoadingProgressTriggersResume) {
+ // Same setup as IdleSuspendIsEnabledBeforeLoadingBegins.
InitializeWebMediaPlayerImpl();
- EXPECT_FALSE(IsSuspended());
- wmpi_->OnSuspendRequested(false);
+ EXPECT_TRUE(delegate_.ExpireForTesting());
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(IsSuspended());
+
+ // Like IdleSuspendIsDisabledIfLoadingProgressedRecently, the idle timeout
+ // should be rejected if it hasn't been long enough.
AddBufferedRanges();
wmpi_->didLoadingProgress();
+ EXPECT_FALSE(delegate_.ExpireForTesting());
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(IsSuspended());
}
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterConstruction) {
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Constructed) {
InitializeWebMediaPlayerImpl();
- WebMediaPlayerImpl::PlayState state;
-
- state = ComputePlayState();
+ WebMediaPlayerImpl::PlayState state = ComputePlayState();
EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
+ EXPECT_TRUE(state.is_idle);
EXPECT_FALSE(state.is_suspended);
-
- state = ComputeIdlePlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
+}
- state = ComputeBackgroundedPlayState();
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_HaveMetadata) {
+ InitializeWebMediaPlayerImpl();
+ SetMetadata(true, true);
+ WebMediaPlayerImpl::PlayState state = ComputePlayState();
EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
+ EXPECT_TRUE(state.is_idle);
EXPECT_FALSE(state.is_suspended);
-
- state = ComputeMustSuspendPlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
}
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterMetadata) {
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_HaveFutureData) {
InitializeWebMediaPlayerImpl();
- WebMediaPlayerImpl::PlayState state;
SetMetadata(true, true);
-
- state = ComputePlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
+ SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+ WebMediaPlayerImpl::PlayState state = ComputePlayState();
+ EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
+ EXPECT_TRUE(state.is_idle);
EXPECT_FALSE(state.is_suspended);
-
- state = ComputeIdlePlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
-
- state = ComputeBackgroundedPlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
-
- state = ComputeMustSuspendPlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
}
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterMetadata_AudioOnly) {
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Playing) {
InitializeWebMediaPlayerImpl();
- WebMediaPlayerImpl::PlayState state;
- SetMetadata(true, false);
-
- state = ComputePlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
+ SetMetadata(true, true);
+ SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+ SetPaused(false);
+ WebMediaPlayerImpl::PlayState state = ComputePlayState();
+ EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state);
+ EXPECT_FALSE(state.is_idle);
EXPECT_FALSE(state.is_suspended);
+ EXPECT_TRUE(state.is_memory_reporting_enabled);
+}
- state = ComputeIdlePlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
-
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Underflow) {
+ InitializeWebMediaPlayerImpl();
+ SetMetadata(true, true);
+ SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
SetPaused(false);
- state = ComputeBackgroundedPlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
+ SetReadyState(blink::WebMediaPlayer::ReadyStateHaveCurrentData);
+ WebMediaPlayerImpl::PlayState state = ComputePlayState();
+ EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state);
+ EXPECT_FALSE(state.is_idle);
EXPECT_FALSE(state.is_suspended);
-
- state = ComputeMustSuspendPlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
+ EXPECT_TRUE(state.is_memory_reporting_enabled);
}
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterFutureData) {
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_FrameHidden) {
InitializeWebMediaPlayerImpl();
- WebMediaPlayerImpl::PlayState state;
SetMetadata(true, true);
SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+ SetPaused(false);
- state = ComputePlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_FALSE(state.is_suspended);
-
- state = ComputeBackgroundedPlayState();
+ {
+ base::test::ScopedFeatureList scoped_feature_list;
+ scoped_feature_list.InitAndEnableFeature(kResumeBackgroundVideo);
- if (base::FeatureList::IsEnabled(kResumeBackgroundVideo))
+ WebMediaPlayerImpl::PlayState state = ComputePlayState_FrameHidden();
EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
- else
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
+ EXPECT_TRUE(state.is_idle);
+ EXPECT_TRUE(state.is_suspended);
+ EXPECT_FALSE(state.is_memory_reporting_enabled);
+ }
- // Idle suspension is possible after HaveFutureData.
- state = ComputeIdlePlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
+ {
+ base::test::ScopedFeatureList scoped_feature_list;
+ scoped_feature_list.InitAndDisableFeature(kResumeBackgroundVideo);
- state = ComputeMustSuspendPlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
+ WebMediaPlayerImpl::PlayState state = ComputePlayState_FrameHidden();
+ EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+ EXPECT_TRUE(state.is_idle);
+ EXPECT_TRUE(state.is_suspended);
+ EXPECT_FALSE(state.is_memory_reporting_enabled);
+ }
}
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_Playing) {
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_FrameClosed) {
InitializeWebMediaPlayerImpl();
- WebMediaPlayerImpl::PlayState state;
SetMetadata(true, true);
SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
SetPaused(false);
-
- state = ComputePlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state);
- EXPECT_TRUE(state.is_memory_reporting_enabled);
- EXPECT_FALSE(state.is_suspended);
-
- state = ComputeBackgroundedPlayState();
- if (base::FeatureList::IsEnabled(kResumeBackgroundVideo))
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
- else
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
-
- state = ComputeMustSuspendPlayState();
+ delegate_.SetFrameClosedForTesting(true);
+ WebMediaPlayerImpl::PlayState state = ComputePlayState();
EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
+ EXPECT_TRUE(state.is_idle);
EXPECT_TRUE(state.is_suspended);
+ EXPECT_FALSE(state.is_memory_reporting_enabled);
}
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_PlayingThenUnderflow) {
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_PausedSeek) {
InitializeWebMediaPlayerImpl();
- WebMediaPlayerImpl::PlayState state;
SetMetadata(true, true);
SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
- SetPaused(false);
- SetReadyState(blink::WebMediaPlayer::ReadyStateHaveCurrentData);
-
- // Underflow should not trigger idle suspend. The user is still playing the
- // the video, just waiting on the network.
- state = ComputePlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state);
- EXPECT_TRUE(state.is_memory_reporting_enabled);
+ SetSeeking(true);
+ WebMediaPlayerImpl::PlayState state = ComputePlayState();
+ EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
+ EXPECT_FALSE(state.is_idle);
EXPECT_FALSE(state.is_suspended);
-
- // Background suspend should still be possible during underflow.
- state = ComputeBackgroundedPlayState();
- if (base::FeatureList::IsEnabled(kResumeBackgroundVideo))
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
- else
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
-
- // Forced suspend should still be possible during underflow.
- state = ComputeMustSuspendPlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
+ EXPECT_TRUE(state.is_memory_reporting_enabled);
}
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_Playing_AudioOnly) {
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Ended) {
InitializeWebMediaPlayerImpl();
- WebMediaPlayerImpl::PlayState state;
- SetMetadata(true, false);
+ SetMetadata(true, true);
SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
SetPaused(false);
+ SetEnded(true);
+ // Before Blink pauses us (or seeks for looping content), the media session
+ // should be preserved.
+ WebMediaPlayerImpl::PlayState state;
state = ComputePlayState();
EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state);
- EXPECT_TRUE(state.is_memory_reporting_enabled);
+ EXPECT_FALSE(state.is_idle);
EXPECT_FALSE(state.is_suspended);
-
- // Audio-only stays playing in the background.
- state = ComputeBackgroundedPlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state);
EXPECT_TRUE(state.is_memory_reporting_enabled);
- EXPECT_FALSE(state.is_suspended);
- // Backgrounding a paused audio only player should suspend, but keep the
- // session alive for user interactions.
SetPaused(true);
- state = ComputeBackgroundedPlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
-
- state = ComputeMustSuspendPlayState();
+ state = ComputePlayState();
EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+ EXPECT_TRUE(state.is_idle);
+ EXPECT_FALSE(state.is_suspended);
EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
}
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_Paused_Seek) {
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_StaysSuspended) {
InitializeWebMediaPlayerImpl();
- WebMediaPlayerImpl::PlayState state;
SetMetadata(true, true);
SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
- SetSeeking(true);
- state = ComputePlayState();
+ // Should stay suspended even though not stale or backgrounded.
+ WebMediaPlayerImpl::PlayState state = ComputePlayState_Suspended();
EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
+ EXPECT_TRUE(state.is_idle);
+ EXPECT_TRUE(state.is_suspended);
EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_FALSE(state.is_suspended);
}
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_Paused_Fullscreen) {
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Remote) {
InitializeWebMediaPlayerImpl();
- WebMediaPlayerImpl::PlayState state;
SetMetadata(true, true);
SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
- SetFullscreen(true);
- state = ComputePlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
+ // Remote media is always suspended.
+ // TODO(sandersd): Decide whether this should count as idle or not.
+ WebMediaPlayerImpl::PlayState state = ComputePlayState_Remote();
+ EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+ EXPECT_TRUE(state.is_suspended);
EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_FALSE(state.is_suspended);
}
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_Ended) {
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Fullscreen) {
InitializeWebMediaPlayerImpl();
- WebMediaPlayerImpl::PlayState state;
SetMetadata(true, true);
SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
- SetEnded(true);
+ SetFullscreen(true);
+ SetPaused(true);
+ delegate_.SetStaleForTesting(true);
- // The pipeline is not suspended immediately on ended.
- state = ComputePlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::ENDED, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
+ // Fullscreen media is never suspended (Android only behavior).
+ WebMediaPlayerImpl::PlayState state = ComputePlayState();
+ EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
+ EXPECT_TRUE(state.is_idle);
EXPECT_FALSE(state.is_suspended);
-
- state = ComputeIdlePlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::ENDED, state.delegate_state);
EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
}
TEST_F(WebMediaPlayerImplTest, ComputePlayState_Streaming) {
InitializeWebMediaPlayerImpl();
- WebMediaPlayerImpl::PlayState state;
SetMetadata(true, true);
-
SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
SetPaused(true);
+ delegate_.SetStaleForTesting(true);
- // Streaming media should not suspend, even if paused, idle, and backgrounded.
- state = ComputeStreamingPlayState(false);
+ // Streaming media should not suspend, even if paused, stale, and
+ // backgrounded.
+ WebMediaPlayerImpl::PlayState state;
+ state = ComputePlayState_BackgroundedStreaming();
EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
+ EXPECT_TRUE(state.is_idle);
EXPECT_FALSE(state.is_suspended);
+ EXPECT_FALSE(state.is_memory_reporting_enabled);
// Streaming media should suspend when the tab is closed, regardless.
- state = ComputeStreamingPlayState(true);
+ delegate_.SetFrameClosedForTesting(true);
+ state = ComputePlayState_BackgroundedStreaming();
EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
+ EXPECT_TRUE(state.is_idle);
EXPECT_TRUE(state.is_suspended);
+ EXPECT_FALSE(state.is_memory_reporting_enabled);
}
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_Suspended) {
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_PlayingBackgroundedVideo) {
+ base::test::ScopedFeatureList scoped_feature_list;
+ scoped_feature_list.InitAndEnableFeature(kResumeBackgroundVideo);
+
InitializeWebMediaPlayerImpl();
- WebMediaPlayerImpl::PlayState state;
SetMetadata(true, true);
+ SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+ SetPaused(false);
+ EXPECT_CALL(delegate_, IsBackgroundVideoPlaybackUnlocked())
+ .WillRepeatedly(Return(true));
- // Suspended players should be resumed unless we have reached the appropriate
- // ready state and are not seeking.
- SetPaused(true);
- state = ComputePlayStateSuspended();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
+ WebMediaPlayerImpl::PlayState state = ComputePlayState_FrameHidden();
+ EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state);
+ EXPECT_FALSE(state.is_idle);
EXPECT_FALSE(state.is_suspended);
+ EXPECT_TRUE(state.is_memory_reporting_enabled);
+}
- // Paused players in the idle state are allowed to remain suspended.
- state = ComputeIdleSuspendedPlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
-
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_AudioOnly) {
+ InitializeWebMediaPlayerImpl();
+ SetMetadata(true, false);
+ SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
SetPaused(false);
- state = ComputePlayStateSuspended();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
+
+ // Backgrounded audio-only playback stays playing.
+ WebMediaPlayerImpl::PlayState state = ComputePlayState_FrameHidden();
+ EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state);
+ EXPECT_FALSE(state.is_idle);
EXPECT_FALSE(state.is_suspended);
+ EXPECT_TRUE(state.is_memory_reporting_enabled);
+}
+TEST_F(WebMediaPlayerImplTest, AutoplayMuted_StartsAndStops) {
+ InitializeWebMediaPlayerImpl();
+ SetMetadata(true, true);
SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
-
- // Paused players should stay suspended.
- SetPaused(true);
- state = ComputePlayStateSuspended();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
-
- // Playing players should resume into the playing state.
SetPaused(false);
- state = ComputePlayStateSuspended();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state);
- EXPECT_TRUE(state.is_memory_reporting_enabled);
- EXPECT_FALSE(state.is_suspended);
+ client_.set_is_autoplaying_muted(true);
- // If seeking, the previously suspended state does not matter; the player
- // should always be resumed.
- SetSeeking(true);
+ EXPECT_CALL(delegate_, DidPlay(_, true, false, _));
+ SetDelegateState(WebMediaPlayerImpl::DelegateState::PLAYING);
- SetPaused(true);
- state = ComputePlayStateSuspended();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_FALSE(state.is_suspended);
+ client_.set_is_autoplaying_muted(false);
+ EXPECT_CALL(delegate_, DidPlay(_, true, true, _));
+ SetDelegateState(WebMediaPlayerImpl::DelegateState::PLAYING);
+}
+TEST_F(WebMediaPlayerImplTest, AutoplayMuted_SetVolume) {
+ InitializeWebMediaPlayerImpl();
+ SetMetadata(true, true);
+ SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
SetPaused(false);
- state = ComputePlayStateSuspended();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state);
- EXPECT_TRUE(state.is_memory_reporting_enabled);
- EXPECT_FALSE(state.is_suspended);
+ client_.set_is_autoplaying_muted(true);
+
+ EXPECT_CALL(delegate_, DidPlay(_, true, false, _));
+ SetDelegateState(WebMediaPlayerImpl::DelegateState::PLAYING);
+
+ client_.set_is_autoplaying_muted(false);
+ EXPECT_CALL(delegate_, DidPlay(_, true, true, _));
+ wmpi_->setVolume(1.0);
}
TEST_F(WebMediaPlayerImplTest, NaturalSizeChange) {
@@ -706,79 +668,12 @@ TEST_F(WebMediaPlayerImplTest, NaturalSizeChange_Rotated) {
ASSERT_EQ(blink::WebSize(1080, 1920), wmpi_->naturalSize());
}
-// Audible backgrounded videos are not suspended if delegate_ allows it.
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_BackgroundedVideoPlaying) {
- InitializeWebMediaPlayerImpl();
- WebMediaPlayerImpl::PlayState state;
- SetMetadata(true, true);
- SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
-
- SetupForResumingBackgroundVideo();
-
- EXPECT_CALL(delegate_, IsPlayingBackgroundVideo())
- .WillRepeatedly(Return(true));
- EXPECT_CALL(delegate_, IsHidden()).WillRepeatedly(Return(true));
-
- SetPaused(false);
- state = ComputeBackgroundedPlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state);
- EXPECT_TRUE(state.is_memory_reporting_enabled);
- EXPECT_FALSE(state.is_suspended);
-}
-
-// Backgrounding audible videos should suspend them and report as paused, not
-// gone.
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_BackgroundedVideoPaused) {
- InitializeWebMediaPlayerImpl();
- WebMediaPlayerImpl::PlayState state;
- SetMetadata(true, true);
- SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
-
- SetupForResumingBackgroundVideo();
-
- EXPECT_CALL(delegate_, IsPlayingBackgroundVideo()).WillOnce(Return(false));
- EXPECT_CALL(delegate_, IsHidden()).WillRepeatedly(Return(true));
-
- state = ComputeBackgroundedPlayState();
- EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
- EXPECT_FALSE(state.is_memory_reporting_enabled);
- EXPECT_TRUE(state.is_suspended);
-}
-
-TEST_F(WebMediaPlayerImplTest, AutoplayMuted_StartsAndStops) {
- InitializeWebMediaPlayerImpl();
- SetMetadata(true, true);
- SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
- SetPaused(false);
-
- EXPECT_CALL(delegate_, DidPlay(_, true, false, false, _));
- client_.set_is_autoplaying_muted(true);
- SetDelegateState(WebMediaPlayerImpl::DelegateState::PLAYING);
-
- EXPECT_CALL(delegate_, DidPlay(_, true, true, false, _));
- client_.set_is_autoplaying_muted(false);
- SetDelegateState(WebMediaPlayerImpl::DelegateState::PLAYING);
-}
-
-TEST_F(WebMediaPlayerImplTest, AutoplayMuted_SetVolume) {
- InitializeWebMediaPlayerImpl();
- SetMetadata(true, true);
- SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
- SetPaused(false);
-
- EXPECT_CALL(delegate_, DidPlay(_, true, false, false, _));
- client_.set_is_autoplaying_muted(true);
- SetDelegateState(WebMediaPlayerImpl::DelegateState::PLAYING);
-
- EXPECT_CALL(delegate_, DidPlay(_, true, true, false, _));
- client_.set_is_autoplaying_muted(false);
- wmpi_->setVolume(1.0);
-}
-
TEST_F(WebMediaPlayerImplTest, ShouldDisableVideoWhenHidden) {
+ base::test::ScopedFeatureList scoped_feature_list;
+ scoped_feature_list.InitAndEnableFeature(kBackgroundVideoTrackOptimization);
+
InitializeWebMediaPlayerImpl();
- EXPECT_CALL(delegate_, IsHidden()).WillRepeatedly(Return(true));
- SetBackgroundVideoOptimization(true);
+ delegate_.SetFrameHiddenForTesting(true);
SetMetadata(true, true);
SetVideoKeyframeDistanceAverage(base::TimeDelta::FromSeconds(5));
@@ -796,9 +691,11 @@ TEST_F(WebMediaPlayerImplTest, ShouldDisableVideoWhenHidden) {
}
TEST_F(WebMediaPlayerImplTest, ShouldDisableVideoWhenHiddenFeatureDisabled) {
+ base::test::ScopedFeatureList scoped_feature_list;
+ scoped_feature_list.InitAndDisableFeature(kBackgroundVideoTrackOptimization);
+
InitializeWebMediaPlayerImpl();
- EXPECT_CALL(delegate_, IsHidden()).WillRepeatedly(Return(true));
- SetBackgroundVideoOptimization(false);
+ delegate_.SetFrameHiddenForTesting(true);
SetMetadata(true, true);
EXPECT_FALSE(ShouldDisableVideoWhenHidden());
« no previous file with comments | « media/blink/webmediaplayer_impl.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698