[Video] MediaSession API event handlers can resume background video.

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 e66351be6ca3629b9923dc00bd4da347dd150d4d..a27a70aa826be750e62e742dedc0ecf048b5db09 100644
--- a/media/blink/webmediaplayer_impl_unittest.cc
+++ b/media/blink/webmediaplayer_impl_unittest.cc
@@ -88,12 +88,15 @@ class DummyWebMediaPlayerClient : public blink::WebMediaPlayerClient {
   void disconnectedFromRemoteDevice() override {}
   void cancelledRemotePlaybackRequest() override {}
   void remotePlaybackStarted() override {}
+  void wasPausedWhenBackgrounded() override {}
+  void wasResumedWhenForegrounded() override {}
   bool isAutoplayingMuted() override { return is_autoplaying_muted_; }
   void requestReload(const blink::WebURL& newUrl) override {}
   bool hasSelectedVideoTrack() override { return false; }
   blink::WebMediaPlayer::TrackId getSelectedVideoTrackId() override {
     return blink::WebMediaPlayer::TrackId();
   }
+  bool isBackgroundVideoPlaybackUnlocked() override { return false; }
 
   void set_is_autoplaying_muted(bool value) { is_autoplaying_muted_ = value; }
 
@@ -303,6 +306,20 @@ class WebMediaPlayerImplTest : public testing::Test {
     wmpi_->SetPipelineMediaDurationForTest(value);
   }
 
+  void SetUpMediaSuspend(bool enable) {
+#if defined(OS_ANDROID)
+    if (!enable) {
+      base::CommandLine::ForCurrentProcess()->AppendSwitch(
+          switches::kDisableMediaSuspend);
+    }
+#else
+    if (enable) {
+      base::CommandLine::ForCurrentProcess()->AppendSwitch(
+          switches::kEnableMediaSuspend);
+    }
+#endif
+  }
+
   // "Renderer" thread.
   base::MessageLoop message_loop_;
 
@@ -459,27 +476,11 @@ TEST_F(WebMediaPlayerImplTest, ComputePlayState_FrameHidden) {
   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);
-  }
+  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_FrameClosed) {
@@ -689,9 +690,12 @@ TEST_F(WebMediaPlayerImplTest, NaturalSizeChange_Rotated) {
   ASSERT_EQ(blink::WebSize(1080, 1920), wmpi_->naturalSize());
 }
 
-TEST_F(WebMediaPlayerImplTest, BackgroundOptimizationsFeatureEnabled) {
+TEST_F(WebMediaPlayerImplTest,
+       BackgroundOptimizationsFeatureEnabledSuspendEnabled) {
   base::test::ScopedFeatureList scoped_feature_list;
   scoped_feature_list.InitAndEnableFeature(kBackgroundVideoTrackOptimization);
+  SetUpMediaSuspend(true);
+
   InitializeWebMediaPlayerImpl(true);
   SetVideoKeyframeDistanceAverage(base::TimeDelta::FromSeconds(5));
   SetDuration(base::TimeDelta::FromSeconds(300));
@@ -700,7 +704,7 @@ TEST_F(WebMediaPlayerImplTest, BackgroundOptimizationsFeatureEnabled) {
   SetMetadata(true, true);
   EXPECT_TRUE(IsBackgroundOptimizationCandidate());
   EXPECT_TRUE(ShouldDisableVideoWhenHidden());
-  EXPECT_FALSE(ShouldPauseVideoWhenHidden());
+  EXPECT_TRUE(ShouldPauseVideoWhenHidden());
 
   // Video only.
   SetMetadata(false, true);
@@ -718,20 +722,22 @@ TEST_F(WebMediaPlayerImplTest, BackgroundOptimizationsFeatureEnabled) {
   SetDuration(base::TimeDelta::FromSeconds(5));
   SetMetadata(true, true);
   EXPECT_TRUE(IsBackgroundOptimizationCandidate());
-  EXPECT_FALSE(ShouldPauseVideoWhenHidden());
+  EXPECT_TRUE(ShouldPauseVideoWhenHidden());
   EXPECT_TRUE(ShouldDisableVideoWhenHidden());
 
   // Average keyframe distance is too big.
   SetVideoKeyframeDistanceAverage(base::TimeDelta::FromSeconds(100));
   SetDuration(base::TimeDelta::FromSeconds(300));
   EXPECT_FALSE(IsBackgroundOptimizationCandidate());
-  EXPECT_FALSE(ShouldPauseVideoWhenHidden());
+  EXPECT_TRUE(ShouldPauseVideoWhenHidden());
   EXPECT_FALSE(ShouldDisableVideoWhenHidden());
 }
 
-TEST_F(WebMediaPlayerImplTest, BackgroundOptimizationsFeatureDisabled) {
+TEST_F(WebMediaPlayerImplTest,
+       BackgroundOptimizationsFeatureDisabledSuspendEnabled) {
   base::test::ScopedFeatureList scoped_feature_list;
   scoped_feature_list.InitAndDisableFeature(kBackgroundVideoTrackOptimization);
+  SetUpMediaSuspend(true);
 
   InitializeWebMediaPlayerImpl(true);
   SetVideoKeyframeDistanceAverage(base::TimeDelta::FromSeconds(5));
@@ -741,15 +747,15 @@ TEST_F(WebMediaPlayerImplTest, BackgroundOptimizationsFeatureDisabled) {
   SetMetadata(true, true);
   EXPECT_TRUE(IsBackgroundOptimizationCandidate());
   EXPECT_FALSE(ShouldDisableVideoWhenHidden());
-  EXPECT_FALSE(ShouldPauseVideoWhenHidden());
+  EXPECT_TRUE(ShouldPauseVideoWhenHidden());
 
-  // Video only (pausing is enabled on Android).
+  // Video only.
   SetMetadata(false, true);
   EXPECT_TRUE(IsBackgroundOptimizationCandidate());
   EXPECT_FALSE(ShouldDisableVideoWhenHidden());
-#if defined(OS_ANDROID)
   EXPECT_TRUE(ShouldPauseVideoWhenHidden());
 
+#if defined(OS_ANDROID)
   // On Android, the duration and keyframe distance don't matter for video-only.
   SetDuration(base::TimeDelta::FromSeconds(5));
   EXPECT_TRUE(IsBackgroundOptimizationCandidate());
@@ -762,8 +768,107 @@ TEST_F(WebMediaPlayerImplTest, BackgroundOptimizationsFeatureDisabled) {
 
   // Restore average keyframe distance.
   SetVideoKeyframeDistanceAverage(base::TimeDelta::FromSeconds(5));
-#else
+#endif
+
+  // Audio only.
+  SetMetadata(true, false);
+  EXPECT_FALSE(IsBackgroundOptimizationCandidate());
+  EXPECT_FALSE(ShouldPauseVideoWhenHidden());
+  EXPECT_FALSE(ShouldDisableVideoWhenHidden());
+
+  // Duration is shorter than max video keyframe distance.
+  SetDuration(base::TimeDelta::FromSeconds(5));
+  SetMetadata(true, true);
+  EXPECT_TRUE(IsBackgroundOptimizationCandidate());
+  EXPECT_TRUE(ShouldPauseVideoWhenHidden());
+  EXPECT_FALSE(ShouldDisableVideoWhenHidden());
+
+  // Average keyframe distance is too big.
+  SetVideoKeyframeDistanceAverage(base::TimeDelta::FromSeconds(100));
+  SetDuration(base::TimeDelta::FromSeconds(300));
+  EXPECT_FALSE(IsBackgroundOptimizationCandidate());
+  EXPECT_TRUE(ShouldPauseVideoWhenHidden());
+  EXPECT_FALSE(ShouldDisableVideoWhenHidden());
+}
+
+TEST_F(WebMediaPlayerImplTest,
+       BackgroundOptimizationsFeatureEnabledSuspendDisabled) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeature(kBackgroundVideoTrackOptimization);
+  SetUpMediaSuspend(false);
+
+  InitializeWebMediaPlayerImpl(true);
+  SetVideoKeyframeDistanceAverage(base::TimeDelta::FromSeconds(5));
+  SetDuration(base::TimeDelta::FromSeconds(300));
+
+  // Audible video.
+  SetMetadata(true, true);
+  EXPECT_TRUE(IsBackgroundOptimizationCandidate());
+  EXPECT_TRUE(ShouldDisableVideoWhenHidden());
+  EXPECT_FALSE(ShouldPauseVideoWhenHidden());
+
+  // Video only.
+  SetMetadata(false, true);
+  EXPECT_TRUE(IsBackgroundOptimizationCandidate());
+  EXPECT_TRUE(ShouldPauseVideoWhenHidden());
+  EXPECT_FALSE(ShouldDisableVideoWhenHidden());
+
+  // Audio only.
+  SetMetadata(true, false);
+  EXPECT_FALSE(IsBackgroundOptimizationCandidate());
+  EXPECT_FALSE(ShouldPauseVideoWhenHidden());
+  EXPECT_FALSE(ShouldDisableVideoWhenHidden());
+
+  // Duration is shorter than max video keyframe distance.
+  SetDuration(base::TimeDelta::FromSeconds(5));
+  SetMetadata(true, true);
+  EXPECT_TRUE(IsBackgroundOptimizationCandidate());
+  EXPECT_FALSE(ShouldPauseVideoWhenHidden());
+  EXPECT_TRUE(ShouldDisableVideoWhenHidden());
+
+  // Average keyframe distance is too big.
+  SetVideoKeyframeDistanceAverage(base::TimeDelta::FromSeconds(100));
+  SetDuration(base::TimeDelta::FromSeconds(300));
+  EXPECT_FALSE(IsBackgroundOptimizationCandidate());
+  EXPECT_FALSE(ShouldPauseVideoWhenHidden());
+  EXPECT_FALSE(ShouldDisableVideoWhenHidden());
+}
+
+TEST_F(WebMediaPlayerImplTest,
+       BackgroundOptimizationsFeatureDisabledSuspendDisabled) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndDisableFeature(kBackgroundVideoTrackOptimization);
+  SetUpMediaSuspend(false);
+
+  InitializeWebMediaPlayerImpl(true);
+  SetVideoKeyframeDistanceAverage(base::TimeDelta::FromSeconds(5));
+  SetDuration(base::TimeDelta::FromSeconds(300));
+
+  // Audible video.
+  SetMetadata(true, true);
+  EXPECT_TRUE(IsBackgroundOptimizationCandidate());
+  EXPECT_FALSE(ShouldDisableVideoWhenHidden());
+  EXPECT_FALSE(ShouldPauseVideoWhenHidden());
+
+  // Video only.
+  SetMetadata(false, true);
+  EXPECT_TRUE(IsBackgroundOptimizationCandidate());
+  EXPECT_FALSE(ShouldDisableVideoWhenHidden());
+  EXPECT_FALSE(ShouldPauseVideoWhenHidden());
+
+#if defined(OS_ANDROID)
+  // On Android, the duration and keyframe distance don't matter for video-only.
+  SetDuration(base::TimeDelta::FromSeconds(5));
+  EXPECT_TRUE(IsBackgroundOptimizationCandidate());
   EXPECT_FALSE(ShouldPauseVideoWhenHidden());
+
+  SetVideoKeyframeDistanceAverage(base::TimeDelta::FromSeconds(100));
+  SetDuration(base::TimeDelta::FromSeconds(300));
+  EXPECT_TRUE(IsBackgroundOptimizationCandidate());
+  EXPECT_FALSE(ShouldPauseVideoWhenHidden());
+
+  // Restore average keyframe distance.
+  SetVideoKeyframeDistanceAverage(base::TimeDelta::FromSeconds(5));
 #endif
 
   // Audio only.