Don't resume paused media. Don't resume playing media after timeout.

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 123 matching lines @@
   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;
   }
 
   WebMediaPlayerImpl::PlayState ComputePlayState() {
     wmpi_->is_idle_ = false;
     wmpi_->must_suspend_ = false;
-    return wmpi_->UpdatePlayState_ComputePlayState(false, false);
+    return wmpi_->UpdatePlayState_ComputePlayState(false, false, false);
+  }
+
+  WebMediaPlayerImpl::PlayState ComputePlayStateSuspended() {
+    wmpi_->is_idle_ = false;
+    wmpi_->must_suspend_ = false;
+    return wmpi_->UpdatePlayState_ComputePlayState(false, true, false);
   }
 
   WebMediaPlayerImpl::PlayState ComputeBackgroundedPlayState() {
     wmpi_->is_idle_ = false;
     wmpi_->must_suspend_ = false;
-    return wmpi_->UpdatePlayState_ComputePlayState(false, true);
+    return wmpi_->UpdatePlayState_ComputePlayState(false, false, true);
   }
 
   WebMediaPlayerImpl::PlayState ComputeIdlePlayState() {
     wmpi_->is_idle_ = true;
     wmpi_->must_suspend_ = false;
-    return wmpi_->UpdatePlayState_ComputePlayState(false, false);
+    return wmpi_->UpdatePlayState_ComputePlayState(false, false, false);
   }
 
   WebMediaPlayerImpl::PlayState ComputeMustSuspendPlayState() {
     wmpi_->is_idle_ = false;
     wmpi_->must_suspend_ = true;
-    return wmpi_->UpdatePlayState_ComputePlayState(false, false);
+    return wmpi_->UpdatePlayState_ComputePlayState(false, false, 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.
@@ skipping 61 matching lines @@
 
 TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterMetadata_AudioOnly) {
   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);
 
-  // Background suspend is not enabled for audio-only.
+  // Background suspend is not enabled for audio-only unless paused.
+  SetPaused(true);
   state = ComputeBackgroundedPlayState();
   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) {
   WebMediaPlayerImpl::PlayState state;
@@ skipping 54 matching lines @@
   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) {
   WebMediaPlayerImpl::PlayState state;
   SetMetadata(true, true);
   SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
@@ skipping 30 matching lines @@
   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) {
+  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);
+
+  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_BUT_NOT_IDLE,
+            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);
+}
+
 }  // namespace media