Refactor WebMediaPlayerDelegate interface.

media/blink/webmediaplayer_impl_unittest.cc

 // 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 "media/blink/webmediaplayer_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 93 matching lines @@
 };
 
 class MockWebMediaPlayerDelegate
     : public WebMediaPlayerDelegate,
       public base::SupportsWeakPtr<MockWebMediaPlayerDelegate> {
  public:
   MockWebMediaPlayerDelegate() = default;
   ~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_) {
+      is_stale_ = true;
+      observer_->OnIdleTimeout();
+    }
+
+    return is_stale_;
+  }
+
+  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 {
  public:
   WebMediaPlayerImplTest()
       : media_thread_("MediaThreadForTest"),
         web_view_(blink::WebView::create(nullptr,
                                          blink::WebPageVisibilityStateVisible)),
         web_local_frame_(
             blink::WebLocalFrame::create(blink::WebTreeScopeType::Document,
@@ skipping 51 matching lines @@
     wmpi_->pipeline_metadata_.has_video = has_video;
   }
 
   void OnMetadata(PipelineMetadata metadata) { wmpi_->OnMetadata(metadata); }
 
   void OnVideoNaturalSizeChange(const gfx::Size& size) {
     wmpi_->OnVideoNaturalSizeChange(size);
   }
 
   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;
+  WebMediaPlayerImpl::PlayState ComputePlayState_FrameHidden() {
+    return wmpi_->UpdatePlayState_ComputePlayState(false, false, false, true);
+  }
+
+  WebMediaPlayerImpl::PlayState ComputePlayState_Suspended() {
     return wmpi_->UpdatePlayState_ComputePlayState(false, false, true, false);
   }
 
-  WebMediaPlayerImpl::PlayState ComputeBackgroundedPlayState() {
-    wmpi_->is_idle_ = false;
-    wmpi_->must_suspend_ = false;
-    return wmpi_->UpdatePlayState_ComputePlayState(false, false, false, true);
+  WebMediaPlayerImpl::PlayState ComputePlayState_Remote() {
+    return wmpi_->UpdatePlayState_ComputePlayState(true, false, false, false);
   }
 
-  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;
-    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 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 SetDelegateState(WebMediaPlayerImpl::DelegateState state) {
+    wmpi_->SetDelegateState(state, false);
   }
 
   // "Renderer" thread.
   base::MessageLoop message_loop_;
 
   // "Media" thread. This is necessary because WMPI destruction waits on a
   // WaitableEvent.
   base::Thread media_thread_;
 
   // Blink state.
   blink::WebFrameClient web_frame_client_;
   blink::WebView* web_view_;
   blink::WebLocalFrame* web_local_frame_;
 
   scoped_refptr<MediaLog> media_log_;
   linked_ptr<media::UrlIndex> url_index_;
 
   // Audio hardware configuration.
   AudioParameters audio_parameters_;
 
   // The client interface used by |wmpi_|. Just a dummy for now, but later we
   // may want a mock or intelligent fake.
   DummyWebMediaPlayerClient client_;
 
   testing::NiceMock<MockWebMediaPlayerDelegate> delegate_;
 
   // 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());
 }
 
 TEST_F(WebMediaPlayerImplTest,
        IdleSuspendIsDisabledIfLoadingProgressedRecently) {
   InitializeWebMediaPlayerImpl();
   base::SimpleTestTickClock* clock = new base::SimpleTestTickClock();
   clock->Advance(base::TimeDelta::FromSeconds(1));
   SetTickClock(clock);
   AddBufferedRanges();
   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());
 }
 
 TEST_F(WebMediaPlayerImplTest, IdleSuspendIsEnabledIfLoadingHasStalled) {
   InitializeWebMediaPlayerImpl();
   base::SimpleTestTickClock* clock = new base::SimpleTestTickClock();
   clock->Advance(base::TimeDelta::FromSeconds(1));
   SetTickClock(clock);
   AddBufferedRanges();
   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) {
-  InitializeWebMediaPlayerImpl();
-  EXPECT_FALSE(IsSuspended());
-  wmpi_->OnSuspendRequested(false);
+  // Same setup as IdleSuspendIsEnabledBeforeLoadingBegins.
+  InitializeWebMediaPlayerImpl();
+  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) {
-  InitializeWebMediaPlayerImpl();
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Constructed) {
+  InitializeWebMediaPlayerImpl();
+  WebMediaPlayerImpl::PlayState 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);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_HaveMetadata) {
+  InitializeWebMediaPlayerImpl();
+  SetMetadata(true, true);
+  WebMediaPlayerImpl::PlayState 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);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_HaveFutureData) {
+  InitializeWebMediaPlayerImpl();
+  SetMetadata(true, true);
+  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);
+  EXPECT_FALSE(state.is_memory_reporting_enabled);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Playing) {
+  InitializeWebMediaPlayerImpl();
+  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);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Underflow) {
+  InitializeWebMediaPlayerImpl();
+  SetMetadata(true, true);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+  SetPaused(false);
+  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);
+  EXPECT_TRUE(state.is_memory_reporting_enabled);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_FrameHidden) {
+  InitializeWebMediaPlayerImpl();
+  SetMetadata(true, true);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+  SetPaused(false);
+
+  {
+    base::test::ScopedFeatureList scoped_feature_list;
+    scoped_feature_list.InitAndEnableFeature(kResumeBackgroundVideo);
+
+    WebMediaPlayerImpl::PlayState state = ComputePlayState_FrameHidden();
+    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);
+  }
+
+  {
+    base::test::ScopedFeatureList scoped_feature_list;
+    scoped_feature_list.InitAndDisableFeature(kResumeBackgroundVideo);
+
+    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_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_TRUE(state.is_idle);
+  EXPECT_TRUE(state.is_suspended);
+  EXPECT_FALSE(state.is_memory_reporting_enabled);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_PausedSeek) {
+  InitializeWebMediaPlayerImpl();
+  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::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);
-
-  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_AfterMetadata) {
-  InitializeWebMediaPlayerImpl();
+  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);
+
+  SetPaused(true);
+  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);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_StaysSuspended) {
+  InitializeWebMediaPlayerImpl();
+  SetMetadata(true, true);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+
+  // 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);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Remote) {
+  InitializeWebMediaPlayerImpl();
+  SetMetadata(true, true);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+
+  // 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);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Fullscreen) {
+  InitializeWebMediaPlayerImpl();
+  SetMetadata(true, true);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+  SetFullscreen(true);
+  SetPaused(true);
+  delegate_.SetStaleForTesting(true);
+
+  // 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);
+  EXPECT_FALSE(state.is_memory_reporting_enabled);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Streaming) {
+  InitializeWebMediaPlayerImpl();
+  SetMetadata(true, true);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+  SetPaused(true);
+  delegate_.SetStaleForTesting(true);
+
+  // Streaming media should not suspend, even if paused, stale, and
+  // backgrounded.
   WebMediaPlayerImpl::PlayState state;
-  SetMetadata(true, true);
-
-  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);
-
-  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) {
-  InitializeWebMediaPlayerImpl();
-  WebMediaPlayerImpl::PlayState state;
+  state = ComputePlayState_BackgroundedStreaming();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
+  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.
+  delegate_.SetFrameClosedForTesting(true);
+  state = ComputePlayState_BackgroundedStreaming();
+  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_PlayingBackgroundedVideo) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeature(kResumeBackgroundVideo);
+
+  InitializeWebMediaPlayerImpl();
+  SetMetadata(true, true);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+  SetPaused(false);
+  EXPECT_CALL(delegate_, IsBackgroundVideoPlaybackAllowed())
+      .WillRepeatedly(Return(true));
+
+  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, ComputePlayState_AudioOnly) {
+  InitializeWebMediaPlayerImpl();
   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();
-  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
-  EXPECT_FALSE(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);
-
-  // 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();
-  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();
-  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
-  EXPECT_FALSE(state.is_memory_reporting_enabled);
-  EXPECT_TRUE(state.is_suspended);
-}
-
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_PlayingThenUnderflow) {
-  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);
-  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);
-}
-
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_Playing_AudioOnly) {
-  InitializeWebMediaPlayerImpl();
-  WebMediaPlayerImpl::PlayState state;
-  SetMetadata(true, false);
-  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);
-
-  // 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();
-  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
-  EXPECT_FALSE(state.is_memory_reporting_enabled);
-  EXPECT_TRUE(state.is_suspended);
-}
-
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_Paused_Seek) {
-  InitializeWebMediaPlayerImpl();
-  WebMediaPlayerImpl::PlayState state;
-  SetMetadata(true, true);
-  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
-  SetSeeking(true);
-
-  state = ComputePlayState();
-  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
-  EXPECT_FALSE(state.is_memory_reporting_enabled);
-  EXPECT_FALSE(state.is_suspended);
-}
-
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_Paused_Fullscreen) {
-  InitializeWebMediaPlayerImpl();
-  WebMediaPlayerImpl::PlayState state;
-  SetMetadata(true, true);
-  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
-  SetFullscreen(true);
-
-  state = ComputePlayState();
-  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
-  EXPECT_FALSE(state.is_memory_reporting_enabled);
-  EXPECT_FALSE(state.is_suspended);
-}
-
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_Ended) {
-  InitializeWebMediaPlayerImpl();
-  WebMediaPlayerImpl::PlayState state;
-  SetMetadata(true, true);
-  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
-  SetEnded(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);
-  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);
-
-  // Streaming media should not suspend, even if paused, idle, and backgrounded.
-  state = ComputeStreamingPlayState(false);
-  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
-  EXPECT_FALSE(state.is_memory_reporting_enabled);
-  EXPECT_FALSE(state.is_suspended);
-
-  // Streaming media should suspend when the tab is closed, regardless.
-  state = ComputeStreamingPlayState(true);
-  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
-  EXPECT_FALSE(state.is_memory_reporting_enabled);
-  EXPECT_TRUE(state.is_suspended);
-}
-
-TEST_F(WebMediaPlayerImplTest, ComputePlayState_Suspended) {
-  InitializeWebMediaPlayerImpl();
-  WebMediaPlayerImpl::PlayState state;
-  SetMetadata(true, 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);
-  EXPECT_FALSE(state.is_suspended);
-
-  // 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);
-
-  SetPaused(false);
-  state = ComputePlayStateSuspended();
-  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
-  EXPECT_FALSE(state.is_memory_reporting_enabled);
-  EXPECT_FALSE(state.is_suspended);
-
-  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);
-
-  // If seeking, the previously suspended state does not matter; the player
-  // should always be resumed.
-  SetSeeking(true);
-
-  SetPaused(true);
-  state = ComputePlayStateSuspended();
-  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
-  EXPECT_FALSE(state.is_memory_reporting_enabled);
-  EXPECT_FALSE(state.is_suspended);
-
-  SetPaused(false);
-  state = ComputePlayStateSuspended();
-  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state);
-  EXPECT_TRUE(state.is_memory_reporting_enabled);
-  EXPECT_FALSE(state.is_suspended);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+  SetPaused(false);
+
+  // 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);
+  SetPaused(false);
+  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, _));
+  SetDelegateState(WebMediaPlayerImpl::DelegateState::PLAYING);
+}
+
+TEST_F(WebMediaPlayerImplTest, AutoplayMuted_SetVolume) {
+  InitializeWebMediaPlayerImpl();
+  SetMetadata(true, true);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+  SetPaused(false);
+  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) {
   InitializeWebMediaPlayerImpl();
   PipelineMetadata metadata;
   metadata.has_video = true;
   metadata.natural_size = gfx::Size(320, 240);
 
   OnMetadata(metadata);
   ASSERT_EQ(blink::WebSize(320, 240), wmpi_->naturalSize());
@@ skipping 11 matching lines @@
   metadata.video_rotation = VIDEO_ROTATION_90;
 
   // For 90/270deg rotations, the natural size should be transposed.
   OnMetadata(metadata);
   ASSERT_EQ(blink::WebSize(240, 320), wmpi_->naturalSize());
 
   OnVideoNaturalSizeChange(gfx::Size(1920, 1080));
   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