Don't suspend the pipeline before HaveFutureData while decoding progressing

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>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/test/simple_test_tick_clock.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/test_helpers.h"
 #include "media/blink/webmediaplayer_delegate.h"
 #include "media/blink/webmediaplayer_params.h"
 #include "media/renderers/default_renderer_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 91 matching lines @@
                                          blink::WebPageVisibilityStateVisible)),
         web_local_frame_(
             blink::WebLocalFrame::create(blink::WebTreeScopeType::Document,
                                          &web_frame_client_)),
         media_log_(new MediaLog()),
         audio_parameters_(TestAudioParameters::Normal()) {
     web_view_->setMainFrame(web_local_frame_);
     media_thread_.StartAndWaitForTesting();
   }
 
-  void InitializeDefaultWebMediaPlayerImpl() {
-    InitializeWebMediaPlayerImpl(delegate_.AsWeakPtr());
-  }
-
-  void InitializeWebMediaPlayerImpl(
-      base::WeakPtr<MockWebMediaPlayerDelegate> delegate) {
+  void InitializeWebMediaPlayerImpl() {
     wmpi_.reset(new WebMediaPlayerImpl(
-        web_local_frame_, &client_, nullptr, delegate,
+        web_local_frame_, &client_, nullptr, delegate_.AsWeakPtr(),
         base::MakeUnique<DefaultRendererFactory>(
             media_log_, nullptr, DefaultRendererFactory::GetGpuFactoriesCB()),
         url_index_,
         WebMediaPlayerParams(
             WebMediaPlayerParams::DeferLoadCB(),
             scoped_refptr<SwitchableAudioRendererSink>(), media_log_,
             media_thread_.task_runner(), message_loop_.task_runner(),
             message_loop_.task_runner(), WebMediaPlayerParams::Context3DCB(),
             base::Bind(&OnAdjustAllocatedMemory), nullptr, nullptr, nullptr)));
   }
@@ skipping 11 matching lines @@
   }
 
  protected:
   void SetReadyState(blink::WebMediaPlayer::ReadyState state) {
     wmpi_->SetReadyState(state);
   }
 
   void SetPaused(bool is_paused) { wmpi_->paused_ = is_paused; }
   void SetSeeking(bool is_seeking) { wmpi_->seeking_ = is_seeking; }
   void SetEnded(bool is_ended) { wmpi_->ended_ = is_ended; }
+  void SetTickClock(base::TickClock* clock) { wmpi_->tick_clock_.reset(clock); }
 
   void SetFullscreen(bool is_fullscreen) {
     wmpi_->overlay_enabled_ = is_fullscreen;
   }
 
   void SetMetadata(bool has_audio, bool has_video) {
     wmpi_->SetNetworkState(blink::WebMediaPlayer::NetworkStateLoaded);
     wmpi_->SetReadyState(blink::WebMediaPlayer::ReadyStateHaveMetadata);
     wmpi_->pipeline_metadata_.has_audio = has_audio;
     wmpi_->pipeline_metadata_.has_video = has_video;
@@ skipping 88 matching lines @@
   testing::NiceMock<MockWebMediaPlayerDelegate> delegate_;
 
   // The WebMediaPlayerImpl instance under test.
   std::unique_ptr<WebMediaPlayerImpl> wmpi_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImplTest);
 };
 
 TEST_F(WebMediaPlayerImplTest, ConstructAndDestroy) {
-  InitializeDefaultWebMediaPlayerImpl();
+  InitializeWebMediaPlayerImpl();
 }
 
-TEST_F(WebMediaPlayerImplTest, DidLoadingProgressClearsIdle) {
-  testing::StrictMock<MockWebMediaPlayerDelegate> strict_delegate;
-  EXPECT_CALL(strict_delegate, AddObserver(_));
-  EXPECT_CALL(strict_delegate, IsPlayingBackgroundVideo()).Times(AnyNumber());
-  InitializeWebMediaPlayerImpl(strict_delegate.AsWeakPtr());
+TEST_F(WebMediaPlayerImplTest, IdleSuspendIsEnabledBeforeLoadingBegins) {
+  InitializeWebMediaPlayerImpl();
+  wmpi_->OnSuspendRequested(false);
+  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);
+  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);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(IsSuspended());
+}
+
+TEST_F(WebMediaPlayerImplTest, DidLoadingProgressTriggersResume) {
+  InitializeWebMediaPlayerImpl();
   EXPECT_FALSE(IsSuspended());
   wmpi_->OnSuspendRequested(false);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(IsSuspended());
   AddBufferedRanges();
   wmpi_->didLoadingProgress();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(IsSuspended());
 }
 
 TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterConstruction) {
-  InitializeDefaultWebMediaPlayerImpl();
+  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();
   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) {
-  InitializeDefaultWebMediaPlayerImpl();
+  InitializeWebMediaPlayerImpl();
   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) {
-  InitializeDefaultWebMediaPlayerImpl();
+  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) {
-  InitializeDefaultWebMediaPlayerImpl();
+  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();
@@ skipping 11 matching lines @@
   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) {
-  InitializeDefaultWebMediaPlayerImpl();
+  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) {
-  InitializeDefaultWebMediaPlayerImpl();
+  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);
@@ skipping 10 matching lines @@
   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) {
-  InitializeDefaultWebMediaPlayerImpl();
+  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);
 
@@ skipping 11 matching lines @@
   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) {
-  InitializeDefaultWebMediaPlayerImpl();
+  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) {
-  InitializeDefaultWebMediaPlayerImpl();
+  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) {
-  InitializeDefaultWebMediaPlayerImpl();
+  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_Suspended) {
-  InitializeDefaultWebMediaPlayerImpl();
+  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);
@@ skipping 37 matching lines @@
   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);
 }
 
 TEST_F(WebMediaPlayerImplTest, NaturalSizeChange) {
-  InitializeDefaultWebMediaPlayerImpl();
+  InitializeWebMediaPlayerImpl();
   PipelineMetadata metadata;
   metadata.has_video = true;
   metadata.natural_size = gfx::Size(320, 240);
 
   OnMetadata(metadata);
   ASSERT_EQ(blink::WebSize(320, 240), wmpi_->naturalSize());
 
   // TODO(sandersd): Verify that the client is notified of the size change?
   OnVideoNaturalSizeChange(gfx::Size(1920, 1080));
   ASSERT_EQ(blink::WebSize(1920, 1080), wmpi_->naturalSize());
 }
 
 TEST_F(WebMediaPlayerImplTest, NaturalSizeChange_Rotated) {
-  InitializeDefaultWebMediaPlayerImpl();
+  InitializeWebMediaPlayerImpl();
   PipelineMetadata metadata;
   metadata.has_video = true;
   metadata.natural_size = gfx::Size(320, 240);
   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) {
-  InitializeDefaultWebMediaPlayerImpl();
+  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) {
-  InitializeDefaultWebMediaPlayerImpl();
+  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) {
-  InitializeDefaultWebMediaPlayerImpl();
+  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) {
-  InitializeDefaultWebMediaPlayerImpl();
+  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