Consider start time for frame painting and fix naming in test.

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 <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 198 matching lines @@
   }
 
   void WaitForEnded() {
     SCOPED_TRACE("WaitForEnded()");
 
     WaitableMessageLoopEvent event;
     EXPECT_CALL(mock_cb_, OnEnded()).WillOnce(RunClosure(event.GetClosure()));
     event.RunAndWait();
   }
 
-  void WaitForPendingRead() {
-    SCOPED_TRACE("WaitForPendingRead()");
+  void WaitForPendingDecode() {
+    SCOPED_TRACE("WaitForPendingDecode()");
     if (!decode_cb_.is_null())
       return;
 
     DCHECK(wait_for_pending_decode_cb_.is_null());
 
     WaitableMessageLoopEvent event;
     wait_for_pending_decode_cb_ = event.GetClosure();
     event.RunAndWait();
 
     DCHECK(!decode_cb_.is_null());
     DCHECK(wait_for_pending_decode_cb_.is_null());
   }
 
-  void SatisfyPendingRead() {
+  void SatisfyPendingDecode() {
     CHECK(!decode_cb_.is_null());
     CHECK(!decode_results_.empty());
 
     // Post tasks for OutputCB and DecodeCB.
     scoped_refptr<VideoFrame> frame = decode_results_.front().second;
     if (frame.get())
       message_loop_.PostTask(FROM_HERE, base::Bind(output_cb_, frame));
     message_loop_.PostTask(
         FROM_HERE, base::Bind(base::ResetAndReturn(&decode_cb_),
                               decode_results_.front().first));
     decode_results_.pop_front();
   }
 
-  void SatisfyPendingReadWithEndOfStream() {
+  void SatisfyPendingDecodeWithEndOfStream() {
     DCHECK(!decode_cb_.is_null());
 
     // Return EOS buffer to trigger EOS frame.
     EXPECT_CALL(demuxer_stream_, Read(_))
         .WillOnce(RunCallback<0>(DemuxerStream::kOk,
                                  DecoderBuffer::CreateEOSBuffer()));
 
     // Satify pending |decode_cb_| to trigger a new DemuxerStream::Read().
     message_loop_.PostTask(
         FROM_HERE,
         base::Bind(base::ResetAndReturn(&decode_cb_), DecodeStatus::OK));
 
-    WaitForPendingRead();
+    WaitForPendingDecode();
 
     message_loop_.PostTask(
         FROM_HERE,
         base::Bind(base::ResetAndReturn(&decode_cb_), DecodeStatus::OK));
   }
 
   void AdvanceWallclockTimeInMs(int time_ms) {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     base::AutoLock l(lock_);
     tick_clock_->Advance(base::TimeDelta::FromMilliseconds(time_ms));
@@ skipping 74 matching lines @@
     renderer_->OnTimeStateChanged(false);
     renderer_->OnTimeStateChanged(true);
 
     // Receiving end of stream should signal having enough.
     {
       SCOPED_TRACE("Waiting for BUFFERING_HAVE_ENOUGH");
       WaitableMessageLoopEvent event;
       EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
           .WillOnce(RunClosure(event.GetClosure()));
       EXPECT_CALL(mock_cb_, OnEnded());
-      SatisfyPendingReadWithEndOfStream();
+      SatisfyPendingDecodeWithEndOfStream();
       event.RunAndWait();
     }
 
     Destroy();
   }
 
   void UnderflowRecoveryTest(UnderflowTestType type) {
     InitializeWithLowDelay(type == UnderflowTestType::LOW_DELAY);
     if (type == UnderflowTestType::CANT_READ_WITHOUT_STALLING)
       ON_CALL(*decoder_, CanReadWithoutStalling()).WillByDefault(Return(false));
@@ skipping 40 matching lines @@
     {
       SCOPED_TRACE("Waiting for BUFFERING_HAVE_ENOUGH");
       WaitableMessageLoopEvent event;
       EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(80))).Times(1);
       EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
           .WillOnce(RunClosure(event.GetClosure()));
       if (type == UnderflowTestType::NORMAL)
         QueueFrames("80 100 120 140 160");
       else
         QueueFrames("40 60 80 90");
-      SatisfyPendingRead();
+      SatisfyPendingDecode();
       event.RunAndWait();
     }
 
     Destroy();
   }
 
  protected:
   // Fixture members.
   std::unique_ptr<VideoRendererImpl> renderer_;
   base::SimpleTestTickClock* tick_clock_;  // Owned by |renderer_|.
@@ skipping 14 matching lines @@
 
   base::MessageLoop message_loop_;
 
  private:
   void DecodeRequested(const scoped_refptr<DecoderBuffer>& buffer,
                        const VideoDecoder::DecodeCB& decode_cb) {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     CHECK(decode_cb_.is_null());
     decode_cb_ = decode_cb;
 
-    // Wake up WaitForPendingRead() if needed.
+    // Wake up WaitForPendingDecode() if needed.
     if (!wait_for_pending_decode_cb_.is_null())
       base::ResetAndReturn(&wait_for_pending_decode_cb_).Run();
 
     if (decode_results_.empty())
       return;
 
-    SatisfyPendingRead();
+    SatisfyPendingDecode();
   }
 
   void FlushRequested(const base::Closure& callback) {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     decode_results_.clear();
     if (!decode_cb_.is_null()) {
       QueueFrames("abort");
-      SatisfyPendingRead();
+      SatisfyPendingDecode();
     }
 
     message_loop_.PostTask(FROM_HERE, callback);
   }
 
   // Used to protect |time_|.
   base::Lock lock_;
   base::TimeDelta time_;
 
   // Used for satisfying reads.
   VideoDecoder::OutputCB output_cb_;
   VideoDecoder::DecodeCB decode_cb_;
   base::TimeDelta next_frame_timestamp_;
 
-  // Run during DecodeRequested() to unblock WaitForPendingRead().
+  // Run during DecodeRequested() to unblock WaitForPendingDecode().
   base::Closure wait_for_pending_decode_cb_;
 
   std::deque<std::pair<DecodeStatus, scoped_refptr<VideoFrame>>>
       decode_results_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoRendererImplTest);
 };
 
 TEST_F(VideoRendererImplTest, DoNothing) {
   // Test that creation and deletion doesn't depend on calls to Initialize()
@@ skipping 17 matching lines @@
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
   EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(0);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, InitializeAndEndOfStream) {
   Initialize();
   StartPlayingFrom(0);
-  WaitForPendingRead();
+  WaitForPendingDecode();
   {
     SCOPED_TRACE("Waiting for BUFFERING_HAVE_ENOUGH");
     WaitableMessageLoopEvent event;
     EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
         .WillOnce(RunClosure(event.GetClosure()));
     EXPECT_CALL(mock_cb_, OnEnded());
-    SatisfyPendingReadWithEndOfStream();
+    SatisfyPendingDecodeWithEndOfStream();
     event.RunAndWait();
   }
   // Firing a time state changed to true should be ignored...
   renderer_->OnTimeStateChanged(true);
   EXPECT_FALSE(null_video_sink_->is_started());
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, DestroyWhileInitializing) {
   CallInitialize(NewExpectedStatusCB(PIPELINE_ERROR_ABORT), false, PIPELINE_OK);
@@ skipping 49 matching lines @@
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
   EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
 
   StartPlayingFrom(0);
   renderer_->OnTimeStateChanged(true);
   time_source_.StartTicking();
   AdvanceTimeInMs(10);
 
   QueueFrames("error");
-  SatisfyPendingRead();
+  SatisfyPendingDecode();
   WaitForError(PIPELINE_ERROR_DECODE);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, DecodeError_DuringStartPlayingFrom) {
   Initialize();
   QueueFrames("error");
   EXPECT_CALL(mock_cb_, OnError(PIPELINE_ERROR_DECODE));
   StartPlayingFrom(0);
   Destroy();
@@ skipping 49 matching lines @@
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
       .Times(AnyNumber());
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
       .Times(AnyNumber());
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
   EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(10);
 
   QueueFrames("20");
-  SatisfyPendingRead();
+  SatisfyPendingDecode();
 
   renderer_->OnTimeStateChanged(true);
   time_source_.StartTicking();
 
   WaitableMessageLoopEvent event;
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(20)))
       .WillOnce(RunClosure(event.GetClosure()));
   AdvanceTimeInMs(20);
   event.RunAndWait();
 
@@ skipping 59 matching lines @@
 
   {
     SCOPED_TRACE("Waiting for first frame to be painted.");
     WaitableMessageLoopEvent event;
 
     EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)))
         .WillOnce(RunClosure(event.GetClosure()));
     StartPlayingFrom(0);
 
     EXPECT_TRUE(IsReadPending());
-    SatisfyPendingReadWithEndOfStream();
+    SatisfyPendingDecodeWithEndOfStream();
 
     event.RunAndWait();
   }
 
   Destroy();
 }
 
 // Verifies that the sink is stopped after rendering the first frame if
 // playback has started.
 TEST_F(VideoRendererImplTest, RenderingStopsAfterOneFrameWithEOS) {
   InitializeWithLowDelay(true);
   QueueFrames("0");
 
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0))).Times(1);
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
   EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
 
   {
     SCOPED_TRACE("Waiting for sink to stop.");
     WaitableMessageLoopEvent event;
 
     null_video_sink_->set_stop_cb(event.GetClosure());
     StartPlayingFrom(0);
     renderer_->OnTimeStateChanged(true);
 
     EXPECT_TRUE(IsReadPending());
-    SatisfyPendingReadWithEndOfStream();
+    SatisfyPendingDecodeWithEndOfStream();
     WaitForEnded();
 
     renderer_->OnTimeStateChanged(false);
     event.RunAndWait();
   }
 
   Destroy();
 }
 
 // Tests the case where the video started and received a single Render() call,
@@ skipping 13 matching lines @@
     EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
     EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
     EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
     StartPlayingFrom(0);
     event.RunAndWait();
     Mock::VerifyAndClearExpectations(&mock_cb_);
   }
 
   // Consider the case that rendering is faster than we setup the test event.
   // In that case, when we run out of the frames, BUFFERING_HAVE_NOTHING will
-  // be called. And then during SatisfyPendingReadWithEndOfStream,
+  // be called. And then during SatisfyPendingDecodeWithEndOfStream,
   // BUFFER_HAVE_ENOUGH will be called again.
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
       .Times(testing::AtMost(1));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
       .Times(testing::AtMost(1));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_))
       .WillRepeatedly(SaveArg<0>(&last_pipeline_statistics));
   renderer_->OnTimeStateChanged(true);
   time_source_.StartTicking();
 
   // Suspend all future callbacks and synthetically advance the media time,
   // because this is a background render, we won't underflow by waiting until
   // a pending read is ready.
   null_video_sink_->set_background_render(true);
   AdvanceTimeInMs(91);
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(90)));
-  WaitForPendingRead();
-  SatisfyPendingReadWithEndOfStream();
+  WaitForPendingDecode();
+  SatisfyPendingDecodeWithEndOfStream();
 
   // If this wasn't background rendering mode, this would result in two frames
   // being dropped, but since we set background render to true, none should be
   // reported
   EXPECT_EQ(0u, last_pipeline_statistics.video_frames_dropped);
   EXPECT_EQ(4u, last_pipeline_statistics.video_frames_decoded);
   EXPECT_EQ(115200, last_pipeline_statistics.video_memory_usage);
 
   AdvanceTimeInMs(30);
   WaitForEnded();
@@ skipping 21 matching lines @@
   {
     SCOPED_TRACE("Waiting for BUFFERING_HAVE_NOTHING");
     WaitableMessageLoopEvent event;
     EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
         .WillOnce(RunClosure(event.GetClosure()));
     renderer_->OnTimeStateChanged(true);
     time_source_.StartTicking();
     event.RunAndWait();
   }
 
-  WaitForPendingRead();
+  WaitForPendingDecode();
 
   // Jump time far enough forward that no frames are valid.
   renderer_->OnTimeStateChanged(false);
   AdvanceTimeInMs(1000);
   time_source_.StopTicking();
 
   // Providing the end of stream packet should remove all frames and exit.
-  SatisfyPendingReadWithEndOfStream();
+  SatisfyPendingDecodeWithEndOfStream();
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   WaitForEnded();
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, StartPlayingFromThenFlushThenEOS) {
   Initialize();
   QueueFrames("0 30 60 90");
 
   WaitableMessageLoopEvent event;
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
       .WillOnce(RunClosure(event.GetClosure()));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
   EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(0);
   event.RunAndWait();
 
   // Cycle ticking so that we get a non-null reference time.
   time_source_.StartTicking();
   time_source_.StopTicking();
 
   // Flush and simulate a seek past EOS, where some error prevents the decoder
   // from returning any frames.
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
   Flush();
 
   StartPlayingFrom(200);
-  WaitForPendingRead();
-  SatisfyPendingReadWithEndOfStream();
+  WaitForPendingDecode();
+  SatisfyPendingDecodeWithEndOfStream();
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   WaitForEnded();
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, FramesAreNotExpiredDuringPreroll) {
   Initialize();
   // !CanReadWithoutStalling() puts the renderer in state BUFFERING_HAVE_ENOUGH
   // after the first frame.
   ON_CALL(*decoder_, CanReadWithoutStalling()).WillByDefault(Return(false));
@@ skipping 189 matching lines @@
   QueueFrames("0 10 20 30");
   StartPlayingFrom(0);
   Flush();
   ASSERT_EQ(1u, frame_ready_cbs_.size());
   // This frame will be discarded.
   frame_ready_cbs_.front().Run();
   Destroy();
 }
 
 }  // namespace media