Connect the new video rendering path to the compositor.

media/renderers/video_renderer_impl_unittest.cc

 // Copyright 2013 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 <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/debug/stack_trace.h"
@@ skipping 18 matching lines @@
 using ::testing::AnyNumber;
 using ::testing::Invoke;
 using ::testing::Mock;
 using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
 namespace media {
 
+// Threshold for Render() callbacks used for testing; should not be zero.
+static const int kTestBackgroundRenderTimeoutMs = 25;
+
 ACTION_P(RunClosure, closure) {
   closure.Run();
 }
 
 MATCHER_P(HasTimestamp, ms, "") {
   *result_listener << "has timestamp " << arg->timestamp().InMilliseconds();
   return arg->timestamp().InMilliseconds() == ms;
 }
 
-class VideoRendererImplTest : public ::testing::Test {
+class VideoRendererImplTest : public testing::TestWithParam<bool> {
  public:
   VideoRendererImplTest()
       : tick_clock_(new base::SimpleTestTickClock()),
         decoder_(new MockVideoDecoder()),
         demuxer_stream_(DemuxerStream::VIDEO) {
     ScopedVector<VideoDecoder> decoders;
     decoders.push_back(decoder_);
 
     // Since the Underflow test needs a render interval shorter than the frame
     // duration, use 120Hz (which makes each interval is < 10ms; ~9.9ms).
     null_video_sink_.reset(new NullVideoSink(
         false, base::TimeDelta::FromSecondsD(1.0 / 120),
         base::Bind(&MockCB::FrameReceived, base::Unretained(&mock_cb_)),
         message_loop_.task_runner()));
 
     renderer_.reset(new VideoRendererImpl(
         message_loop_.message_loop_proxy(), null_video_sink_.get(),
         decoders.Pass(), true, new MediaLog()));
-
+    if (GetParam())
+      renderer_->enable_new_video_renderer_for_testing();
     renderer_->SetTickClockForTesting(scoped_ptr<base::TickClock>(tick_clock_));
     null_video_sink_->set_tick_clock_for_testing(tick_clock_);
 
+    // Disable background rendering for tests by default.
+    renderer_->SetBackgroundRenderingForTesting(false, base::TimeDelta());
+
     // Start wallclock time at a non-zero value.
     AdvanceWallclockTimeInMs(12345);
 
     demuxer_stream_.set_video_decoder_config(TestVideoConfig::Normal());
 
     // We expect these to be called but we don't care how/when.
     EXPECT_CALL(demuxer_stream_, Read(_)).WillRepeatedly(
         RunCallback<0>(DemuxerStream::kOk,
                        scoped_refptr<DecoderBuffer>(new DecoderBuffer(0))));
   }
@@ skipping 57 matching lines @@
     renderer_->Flush(event.GetClosure());
     event.RunAndWait();
   }
 
   void Destroy() {
     SCOPED_TRACE("Destroy()");
     renderer_.reset();
     message_loop_.RunUntilIdle();
   }
 
+  void SuspendRenderCallbacks() {
+    null_video_sink_->pause_callbacks(base::TimeTicks() +
+                                      base::TimeDelta::Max());
+  }
+
   // Parses a string representation of video frames and generates corresponding
   // VideoFrame objects in |decode_results_|.
   //
   // Syntax:
   //   nn - Queue a decoder buffer with timestamp nn * 1000us
   //   abort - Queue an aborted read
   //   error - Queue a decoder error
   //
   // Examples:
   //   A clip that is four frames long: "0 10 20 30"
@@ skipping 101 matching lines @@
     base::AutoLock l(lock_);
     tick_clock_->Advance(base::TimeDelta::FromMilliseconds(time_ms));
   }
 
   void AdvanceTimeInMs(int time_ms) {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     base::AutoLock l(lock_);
     time_ += base::TimeDelta::FromMilliseconds(time_ms);
   }
 
+  bool has_ended() const {
+    return ended_event_.is_signaled();
+  }
+
  protected:
   // Fixture members.
   scoped_ptr<VideoRendererImpl> renderer_;
   base::SimpleTestTickClock* tick_clock_;  // Owned by |renderer_|.
   MockVideoDecoder* decoder_;  // Owned by |renderer_|.
   NiceMock<MockDemuxerStream> demuxer_stream_;
 
   // Use StrictMock<T> to catch missing/extra callbacks.
   class MockCB {
    public:
@@ skipping 58 matching lines @@
 
   // Run during DecodeRequested() to unblock WaitForPendingRead().
   base::Closure wait_for_pending_decode_cb_;
 
   std::deque<std::pair<
       VideoDecoder::Status, scoped_refptr<VideoFrame> > > decode_results_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoRendererImplTest);
 };
 
-TEST_F(VideoRendererImplTest, DoNothing) {
+TEST_P(VideoRendererImplTest, DoNothing) {
   // Test that creation and deletion doesn't depend on calls to Initialize()
   // and/or Destroy().
 }
 
-TEST_F(VideoRendererImplTest, DestroyWithoutInitialize) {
+TEST_P(VideoRendererImplTest, DestroyWithoutInitialize) {
   Destroy();
 }
 
-TEST_F(VideoRendererImplTest, Initialize) {
+TEST_P(VideoRendererImplTest, Initialize) {
   Initialize();
   Destroy();
 }
 
-TEST_F(VideoRendererImplTest, InitializeAndStartPlayingFrom) {
+TEST_P(VideoRendererImplTest, InitializeAndStartPlayingFrom) {
   Initialize();
   QueueFrames("0 10 20 30");
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(0);
   Destroy();
 }
 
-TEST_F(VideoRendererImplTest, DestroyWhileInitializing) {
+TEST_P(VideoRendererImplTest, DestroyWhileInitializing) {
   CallInitialize(NewExpectedStatusCB(PIPELINE_ERROR_ABORT), false, PIPELINE_OK);
   Destroy();
 }
 
-TEST_F(VideoRendererImplTest, DestroyWhileFlushing) {
+TEST_P(VideoRendererImplTest, DestroyWhileFlushing) {
   Initialize();
   QueueFrames("0 10 20 30");
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(0);
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_NOTHING));
   renderer_->Flush(NewExpectedClosure());
   Destroy();
 }
 
-TEST_F(VideoRendererImplTest, Play) {
+TEST_P(VideoRendererImplTest, Play) {
   Initialize();
   QueueFrames("0 10 20 30");
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(0);
   Destroy();
 }
 
-TEST_F(VideoRendererImplTest, FlushWithNothingBuffered) {
+TEST_P(VideoRendererImplTest, FlushWithNothingBuffered) {
   Initialize();
   StartPlayingFrom(0);
 
   // We shouldn't expect a buffering state change since we never reached
   // BUFFERING_HAVE_ENOUGH.
   Flush();
   Destroy();
 }
 
-TEST_F(VideoRendererImplTest, DecodeError_Playing) {
+TEST_P(VideoRendererImplTest, DecodeError_Playing) {
   Initialize();
   QueueFrames("0 10 20 30");
   EXPECT_CALL(mock_cb_, FrameReceived(_)).Times(testing::AtLeast(1));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(0);
 
-  WaitForPendingRead();
-
   QueueFrames("error");
   SatisfyPendingRead();
   WaitForError(PIPELINE_ERROR_DECODE);
   Destroy();
 }
 
-TEST_F(VideoRendererImplTest, DecodeError_DuringStartPlayingFrom) {
+TEST_P(VideoRendererImplTest, DecodeError_DuringStartPlayingFrom) {
   Initialize();
   QueueFrames("error");
   StartPlayingFrom(0);
   Destroy();
 }
 
-TEST_F(VideoRendererImplTest, StartPlayingFrom_Exact) {
+TEST_P(VideoRendererImplTest, StartPlayingFrom_Exact) {
   Initialize();
   QueueFrames("50 60 70 80 90");
 
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(60)));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(60);
   Destroy();
 }
 
-TEST_F(VideoRendererImplTest, StartPlayingFrom_RightBefore) {
+TEST_P(VideoRendererImplTest, StartPlayingFrom_RightBefore) {
   Initialize();
   QueueFrames("50 60 70 80 90");
 
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(50)));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(59);
   Destroy();
 }
 
-TEST_F(VideoRendererImplTest, StartPlayingFrom_RightAfter) {
+TEST_P(VideoRendererImplTest, StartPlayingFrom_RightAfter) {
   Initialize();
   QueueFrames("50 60 70 80 90");
 
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(60)));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(61);
   Destroy();
 }
 
-TEST_F(VideoRendererImplTest, StartPlayingFrom_LowDelay) {
+TEST_P(VideoRendererImplTest, StartPlayingFrom_LowDelay) {
   // In low-delay mode only one frame is required to finish preroll.
   InitializeWithLowDelay(true);
   QueueFrames("0");
 
   // Expect some amount of have enough/nothing due to only requiring one frame.
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
       .Times(AnyNumber());
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_NOTHING))
       .Times(AnyNumber());
   StartPlayingFrom(0);
 
   QueueFrames("10");
   SatisfyPendingRead();
 
+  renderer_->OnTimeStateChanged(true);
   WaitableMessageLoopEvent event;
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(10)))
       .WillOnce(RunClosure(event.GetClosure()));
   AdvanceTimeInMs(10);
   event.RunAndWait();
 
   Destroy();
 }
 
 // Verify that a late decoder response doesn't break invariants in the renderer.
-TEST_F(VideoRendererImplTest, DestroyDuringOutstandingRead) {
+TEST_P(VideoRendererImplTest, DestroyDuringOutstandingRead) {
   Initialize();
   QueueFrames("0 10 20 30");
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(0);
 
   // Check that there is an outstanding Read() request.
   EXPECT_TRUE(IsReadPending());
 
   Destroy();
 }
 
-TEST_F(VideoRendererImplTest, VideoDecoder_InitFailure) {
+TEST_P(VideoRendererImplTest, VideoDecoder_InitFailure) {
   InitializeRenderer(DECODER_ERROR_NOT_SUPPORTED, false);
   Destroy();
 }
 
-TEST_F(VideoRendererImplTest, Underflow) {
+TEST_P(VideoRendererImplTest, Underflow) {
   Initialize();
   QueueFrames("0 10 20 30");
 
   {
     WaitableMessageLoopEvent event;
     EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
     EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
         .WillOnce(RunClosure(event.GetClosure()));
     StartPlayingFrom(0);
     event.RunAndWait();
     Mock::VerifyAndClearExpectations(&mock_cb_);
   }
 
+  renderer_->OnTimeStateChanged(true);
+
   // Advance time slightly, but enough to exceed the duration of the last frame.
   // Frames should be dropped and we should NOT signal having nothing.
   {
     SCOPED_TRACE("Waiting for frame drops");
     WaitableMessageLoopEvent event;
     EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(10)))
         .Times(0);
     EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(20)))
         .Times(0);
     EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(30)))
@@ skipping 22 matching lines @@
     EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
         .WillOnce(RunClosure(event.GetClosure()));
     SatisfyPendingReadWithEndOfStream();
     event.RunAndWait();
   }
 
   WaitForEnded();
   Destroy();
 }
 
+// Tests the case where the video started in the background and never received
+// any Render() calls and time never started progressing (so the sink should be
+// stopped immediately).
+TEST_P(VideoRendererImplTest, BackgroundRenderingStopsAfterFirstFrame) {
+  // This test is only for the new rendering path.
+  if (!GetParam())
+    return;
+
+  // By default, tests disable background rendering, so enable it now and give
+  // a short, but non-zero, timeout.
+  renderer_->SetBackgroundRenderingForTesting(
+      true, base::TimeDelta::FromMilliseconds(kTestBackgroundRenderTimeoutMs));
+
+  InitializeWithLowDelay(true);
+  QueueFrames("0");
+
+  EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
+
+  // Pause callbacks forever, but don't start the sink. Ended should not fire.
+  SuspendRenderCallbacks();
+  StartPlayingFrom(0);
+  EXPECT_TRUE(IsReadPending());
+  SatisfyPendingReadWithEndOfStream();
+
+  {
+    SCOPED_TRACE("Waiting for sink to stop.");
+    WaitableMessageLoopEvent event;
+    null_video_sink_->set_stop_callback(event.GetClosure());
+    event.RunAndWait();
+  }
+
+  EXPECT_FALSE(has_ended());
+  Destroy();
+}
+
+// Tests the case where the video started in the background and never received
+// any Render() calls, but time is progressing.
+TEST_P(VideoRendererImplTest, BackgroundRenderingNeverStarted) {
+  // This test is only for the new rendering path.
+  if (!GetParam())
+    return;
+
+  // By default, tests disable background rendering, so enable it now and give
+  // a short, but non-zero, timeout.
+  renderer_->SetBackgroundRenderingForTesting(
+      true, base::TimeDelta::FromMilliseconds(kTestBackgroundRenderTimeoutMs));
+
+  Initialize();
+  QueueFrames("0 10 20 30");
+
+  EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
+
+  // Start the sink and pause callbacks forever.
+  renderer_->OnTimeStateChanged(true);
+  SuspendRenderCallbacks();
+  StartPlayingFrom(0);
+  AdvanceTimeInMs(41);
+
+  // Eventually background rendering should request new buffers and at that
+  // point fire the ended event if rendering has completed.
+  WaitForPendingRead();
+  SatisfyPendingReadWithEndOfStream();
+  WaitForEnded();
+  Destroy();
+}
+
+// Tests the case where the video started in the background and never received
+// any Render() calls, but time is progressing and there's only a single frame
+// in the video.
+TEST_P(VideoRendererImplTest, BackgroundRenderingNeverStartedSingleFrame) {
+  // This test is only for the new rendering path.
+  if (!GetParam())
+    return;
+
+  // By default, tests disable background rendering, so enable it now and give
+  // a short, but non-zero, timeout.
+  renderer_->SetBackgroundRenderingForTesting(
+      true, base::TimeDelta::FromMilliseconds(kTestBackgroundRenderTimeoutMs));
+
+  Initialize();
+  QueueFrames("0");
+
+  EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
+
+  // Start the sink and pause callbacks forever.
+  renderer_->OnTimeStateChanged(true);
+  SuspendRenderCallbacks();
+  StartPlayingFrom(0);
+
+  // Eventually background rendering should request new buffers and at that
+  // point fire the ended event if rendering has completed.
+  WaitForPendingRead();
+  SatisfyPendingReadWithEndOfStream();
+  WaitForEnded();
+  Destroy();
+}
+
+// Tests the case where the video started and received a single Render() call,
+// then the video was put into the background.
+TEST_P(VideoRendererImplTest, BackgroundRenderingRenderStartedThenStopped) {
+  // This test is only for the new rendering path.
+  if (!GetParam())
+    return;
+
+  // By default, tests disable background rendering, so enable it now and give
+  // a short, but non-zero, timeout.
+  renderer_->SetBackgroundRenderingForTesting(
+      true, base::TimeDelta::FromMilliseconds(kTestBackgroundRenderTimeoutMs));
+
+  Initialize();
+  QueueFrames("0 10 20 30");
+
+  // Start the sink and wait for the first callback.
+  {
+    WaitableMessageLoopEvent event;
+    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
+    EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
+        .WillOnce(RunClosure(event.GetClosure()));
+    StartPlayingFrom(0);
+    event.RunAndWait();
+    Mock::VerifyAndClearExpectations(&mock_cb_);
+  }
+
+  renderer_->OnTimeStateChanged(true);
+
+  // Suspend all future callbacks and synthetically advance the media time.
+  SuspendRenderCallbacks();
+  AdvanceTimeInMs(41);
+
+  // Eventually background rendering should request new buffers and at that
+  // point fire the ended event if rendering has completed.
+  WaitForPendingRead();
+  SatisfyPendingReadWithEndOfStream();
+  WaitForEnded();
+  Destroy();
+}
+
+INSTANTIATE_TEST_CASE_P(VideoRendererImplTest,
+                        VideoRendererImplTest,
+                        testing::Bool());
+
 }  // namespace media