Convert WMPI state management to level-triggered.

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 <stdint.h>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 106 matching lines @@
     // NOTE: This should be done before any other member variables are
     // destructed since WMPI may reference them during destruction.
     wmpi_.reset();
     message_loop_.RunUntilIdle();
 
     web_view_->close();
     web_local_frame_->close();
   }
 
  protected:
+  void SetReadyState(blink::WebMediaPlayer::ReadyState state) {
+    wmpi_->SetReadyState(state);
+  }
+
+  void SetPaused(bool is_paused) { wmpi_->paused_ = is_paused; }
+
+  void SetEnded(bool is_ended) { wmpi_->ended_ = is_ended; }
+
+  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);
+  }
+
+  WebMediaPlayerImpl::PlayState ComputeBackgroundedPlayState() {
+    wmpi_->is_idle_ = false;
+    wmpi_->must_suspend_ = false;
+    return wmpi_->UpdatePlayState_ComputePlayState(false, true);
+  }
+
+  WebMediaPlayerImpl::PlayState ComputeIdlePlayState() {
+    wmpi_->is_idle_ = true;
+    wmpi_->must_suspend_ = false;
+    return wmpi_->UpdatePlayState_ComputePlayState(false, false);
+  }
+
+  WebMediaPlayerImpl::PlayState ComputeMustSuspendPlayState() {
+    wmpi_->is_idle_ = false;
+    wmpi_->must_suspend_ = true;
+    return wmpi_->UpdatePlayState_ComputePlayState(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.
   DummyWebFrameClient web_frame_client_;
   blink::WebView* web_view_;
@@ skipping 12 matching lines @@
 
   // The WebMediaPlayerImpl instance under test.
   scoped_ptr<WebMediaPlayerImpl> wmpi_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImplTest);
 };
 
 TEST_F(WebMediaPlayerImplTest, ConstructAndDestroy) {}
 
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterConstruction) {
+  WebMediaPlayerImpl::PlayState state;
+
+  state = ComputePlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);

[watk, 2016/04/02 00:12:53]

All these WebMediaPlayerImpls only add noise. I wonder if you could do using
DelegateState = WebMediaPlayerImpl::DelegateState or something?

[sandersd (OOO until July 31), 2016/04/04 19:47:37]

Ack.

I think I'll hold off for now, hopefully there is an overall more clear
structure waiting to be found.

+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(false, state.is_suspended);
+
+  state = ComputeBackgroundedPlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(false, state.is_suspended);
+
+  state = ComputeMustSuspendPlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(true, state.is_suspended);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterMetadata) {
+  WebMediaPlayerImpl::PlayState state;
+  SetMetadata(true, true);
+
+  state = ComputePlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(false, state.is_suspended);
+
+  state = ComputeBackgroundedPlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(true, state.is_suspended);
+
+  state = ComputeMustSuspendPlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(true, state.is_suspended);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterMetadata_AudioOnly) {
+  WebMediaPlayerImpl::PlayState state;
+  SetMetadata(true, false);
+
+  state = ComputePlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(false, state.is_suspended);
+
+  // Background suspend is not enabled for audio-only.
+  state = ComputeBackgroundedPlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(false, state.is_suspended);
+
+  state = ComputeMustSuspendPlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(true, state.is_suspended);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterFutureData) {
+  WebMediaPlayerImpl::PlayState state;
+  SetMetadata(true, true);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+
+  state = ComputePlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(false, state.is_suspended);
+
+  state = ComputeBackgroundedPlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(true, state.is_suspended);
+
+  // Idle suspension is possible after HaveFutureData.
+  state = ComputeIdlePlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(true, state.is_suspended);
+
+  state = ComputeMustSuspendPlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(true, state.is_suspended);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Playing) {
+  WebMediaPlayerImpl::PlayState state;
+  SetMetadata(true, true);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+  SetPaused(false);
+
+  state = ComputePlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state);
+  EXPECT_EQ(true, state.is_memory_reporting_enabled);
+  EXPECT_EQ(false, state.is_suspended);
+
+  state = ComputeBackgroundedPlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(true, state.is_suspended);
+
+  state = ComputeMustSuspendPlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(true, state.is_suspended);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Playing_AudioOnly) {
+  WebMediaPlayerImpl::PlayState state;
+  SetMetadata(true, false);
+  SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData);
+  SetPaused(false);
+
+  state = ComputePlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state);
+  EXPECT_EQ(true, state.is_memory_reporting_enabled);
+  EXPECT_EQ(false, state.is_suspended);
+
+  // Audio-only stays playing in the background.
+  state = ComputeBackgroundedPlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state);
+  EXPECT_EQ(true, state.is_memory_reporting_enabled);
+  EXPECT_EQ(false, state.is_suspended);
+
+  state = ComputeMustSuspendPlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(true, state.is_suspended);
+}
+
+TEST_F(WebMediaPlayerImplTest, ComputePlayState_Ended) {
+  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_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(false, state.is_suspended);
+
+  state = ComputeIdlePlayState();
+  EXPECT_EQ(WebMediaPlayerImpl::DelegateState::ENDED, state.delegate_state);
+  EXPECT_EQ(false, state.is_memory_reporting_enabled);
+  EXPECT_EQ(true, state.is_suspended);
+}
+
 }  // namespace media