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

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 70 matching lines @@
   void addTextTrack(blink::WebInbandTextTrack*) override {}
   void removeTextTrack(blink::WebInbandTextTrack*) override {}
   void mediaSourceOpened(blink::WebMediaSource*) override {}
   void requestSeek(double) override {}
   void remoteRouteAvailabilityChanged(
       blink::WebRemotePlaybackAvailability) override {}
   void connectedToRemoteDevice() override {}
   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; }
 
  private:
   bool is_autoplaying_muted_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(DummyWebMediaPlayerClient);
 };
 
 class MockWebMediaPlayerDelegate : public WebMediaPlayerDelegate {
@@ skipping 189 matching lines @@
   void SetVideoKeyframeDistanceAverage(base::TimeDelta value) {
     PipelineStatistics statistics;
     statistics.video_keyframe_distance_average = value;
     wmpi_->SetPipelineStatisticsForTest(statistics);
   }
 
   void SetDuration(base::TimeDelta value) {
     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_;
 
   // "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_;
@@ skipping 136 matching lines @@
   EXPECT_FALSE(state.is_suspended);
   EXPECT_TRUE(state.is_memory_reporting_enabled);
 }
 
 TEST_F(WebMediaPlayerImplTest, ComputePlayState_FrameHidden) {
   InitializeWebMediaPlayerImpl(true);
   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);
-  }
+  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) {
   InitializeWebMediaPlayerImpl(true);
   SetMetadata(true, true);
   SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
   SetPaused(false);
   delegate_.SetFrameClosedForTesting(true);
   WebMediaPlayerImpl::PlayState state = ComputePlayState();
   EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
@@ skipping 189 matching lines @@
   metadata.video_rotation = VIDEO_ROTATION_90;
 
   OnMetadata(metadata);
   ASSERT_EQ(blink::WebSize(320, 240), wmpi_->naturalSize());
 
   // For 90/270deg rotations, the natural size should be transposed.
   OnVideoNaturalSizeChange(gfx::Size(1920, 1080));
   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));
 
   // Audible video.
   SetMetadata(true, true);
   EXPECT_TRUE(IsBackgroundOptimizationCandidate());
   EXPECT_TRUE(ShouldDisableVideoWhenHidden());
-  EXPECT_FALSE(ShouldPauseVideoWhenHidden());
+  EXPECT_TRUE(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(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));
   SetDuration(base::TimeDelta::FromSeconds(300));
 
   // Audible video.
   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());
   EXPECT_TRUE(ShouldPauseVideoWhenHidden());
 
   SetVideoKeyframeDistanceAverage(base::TimeDelta::FromSeconds(100));
   SetDuration(base::TimeDelta::FromSeconds(300));
   EXPECT_TRUE(IsBackgroundOptimizationCandidate());
   EXPECT_TRUE(ShouldPauseVideoWhenHidden());
 
   // Restore average keyframe distance.
   SetVideoKeyframeDistanceAverage(base::TimeDelta::FromSeconds(5));
-#else
-  EXPECT_FALSE(ShouldPauseVideoWhenHidden());
 #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.
   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_FALSE(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());
 }
 
 }  // namespace media