Refactor WebMediaPlayerDelegate interface.

media/blink/webmediaplayer_impl_unittest.cc

Index: media/blink/webmediaplayer_impl_unittest.cc
diff --git a/media/blink/webmediaplayer_impl_unittest.cc b/media/blink/webmediaplayer_impl_unittest.cc
index d7ef58e8525b61b96e94f1e8d190b290c12769e2..ea2582797f5c9b47622e45d6435a957da559608f 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(IsBackgroundVideoPlaybackAllowed, 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_;
+  }
+
+  // Currently |is_backgrounded| overrides this completely, so no explicit
+  // control is needed.
+  bool IsFrameHidden() override { return is_closed_; }
+
+  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_) {
+      if (observer_->OnIdleTimeout()) {
+        is_stale_ = true;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  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_closed_ = false;
 };
 
 class WebMediaPlayerImplTest : public testing::Test {
@@ -189,51 +251,25 @@ 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() {
@@ -249,6 +285,10 @@ class WebMediaPlayerImplTest : public testing::Test {
     scoped_feature_list_.InitAndEnableFeature(kResumeBackgroundVideo);
   }
 
+  void SetDelegateState(WebMediaPlayerImpl::DelegateState state) {
+    wmpi_->SetDelegateState(state, false);
+  }
+
   // "Renderer" thread.
   base::MessageLoop message_loop_;
 
@@ -284,11 +324,12 @@ class WebMediaPlayerImplTest : public testing::Test {
 
 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());
 }
@@ -303,7 +344,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());
 }
@@ -317,344 +358,273 @@ 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();
-  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
-  EXPECT_FALSE(state.is_memory_reporting_enabled);
-  EXPECT_FALSE(state.is_suspended);
-
-  state = ComputeIdlePlayState();
+  WebMediaPlayerImpl::PlayState state = ComputePlayState();
   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_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_HaveMetadata) {
   InitializeWebMediaPlayerImpl();
-  WebMediaPlayerImpl::PlayState state;
   SetMetadata(true, true);
-
-  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();
-  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_HaveFutureData) {
   InitializeWebMediaPlayerImpl();
-  WebMediaPlayerImpl::PlayState state;
-  SetMetadata(true, false);
-
-  state = ComputePlayState();
-  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
-  EXPECT_FALSE(state.is_memory_reporting_enabled);
-  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);
-
-  SetPaused(false);
-  state = ComputeBackgroundedPlayState();
-  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
-  EXPECT_FALSE(state.is_memory_reporting_enabled);
-  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_AfterFutureData) {
-  InitializeWebMediaPlayerImpl();
-  WebMediaPlayerImpl::PlayState state;
   SetMetadata(true, true);
   SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
-
-  state = ComputePlayState();
+  WebMediaPlayerImpl::PlayState state = ComputePlayState();
   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);
-
-  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);
-
-  // 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);
-
-  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_Playing) {
   InitializeWebMediaPlayerImpl();
-  WebMediaPlayerImpl::PlayState state;
   SetMetadata(true, true);
   SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
   SetPaused(false);
-
-  state = ComputePlayState();
+  WebMediaPlayerImpl::PlayState 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);
-
-  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();
-  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_PlayingThenUnderflow) {
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Underflow) {
   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();
+  WebMediaPlayerImpl::PlayState 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);
+  EXPECT_TRUE(state.is_memory_reporting_enabled);
+}
 
-  // Background suspend should still be possible during underflow.
-  state = ComputeBackgroundedPlayState();
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_FrameHidden) {
+  InitializeWebMediaPlayerImpl();
+  SetMetadata(true, true);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+  SetPaused(false);
+  WebMediaPlayerImpl::PlayState state = ComputePlayState_FrameHidden();
+  // TODO(sandersd): Make sure both variants are tested.

[whywhat, 2016/12/12 18:11:23]

nit: the enabled version should be tested on Android at least, I don't recall
why it didn't work on desktop at the time I added this but IIRC it didn't, hence
the if instead of two cases where one sets the flag to true and another to
false. maybe worth trying again?

[sandersd (OOO until July 31), 2017/01/05 23:12:21]

Done.

   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_idle);
   EXPECT_TRUE(state.is_suspended);
+  EXPECT_FALSE(state.is_memory_reporting_enabled);
+}
 
-  // Forced suspend should still be possible during underflow.
-  state = ComputeMustSuspendPlayState();
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_FrameClosed) {
+  InitializeWebMediaPlayerImpl();
+  SetMetadata(true, true);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+  SetPaused(false);
+  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_Playing_AudioOnly) {
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_PausedSeek) {
   InitializeWebMediaPlayerImpl();
-  WebMediaPlayerImpl::PlayState state;
-  SetMetadata(true, false);
+  SetMetadata(true, true);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+  SetSeeking(true);
+  WebMediaPlayerImpl::PlayState state = ComputePlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
+  EXPECT_FALSE(state.is_idle);
+  EXPECT_FALSE(state.is_suspended);
+  EXPECT_TRUE(state.is_memory_reporting_enabled);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Ended) {
+  InitializeWebMediaPlayerImpl();
+  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) {
+  SetupForResumingBackgroundVideo();
+
   InitializeWebMediaPlayerImpl();
-  WebMediaPlayerImpl::PlayState state;
   SetMetadata(true, true);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+  SetPaused(false);
+  EXPECT_CALL(delegate_, IsBackgroundVideoPlaybackAllowed())
+      .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(_, false, true, _));
+  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(_, false, true, _));
+  SetDelegateState(WebMediaPlayerImpl::DelegateState::PLAYING);
+
+  client_.set_is_autoplaying_muted(false);
+  EXPECT_CALL(delegate_, DidPlay(_, true, true, _));
+  wmpi_->setVolume(1.0);
 }
 
 TEST_F(WebMediaPlayerImplTest, NaturalSizeChange) {
@@ -686,73 +656,4 @@ 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);
-}
-
 }  // namespace media