Make painting a single frame a permanent API on VideoRendererSink.

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 706 matching lines @@
 }
 
 TEST_F(VideoRendererImplTest, UnderflowRecovery_LowDelay) {
   UnderflowRecoveryTest(UnderflowTestType::LOW_DELAY);
 }
 
 TEST_F(VideoRendererImplTest, UnderflowRecovery_CantReadWithoutStalling) {
   UnderflowRecoveryTest(UnderflowTestType::CANT_READ_WITHOUT_STALLING);
 }
 
-// Verifies that the sink is stopped after rendering the first frame if
-// playback hasn't started.
+// Verifies that the first frame is painted w/o rendering being started.
 TEST_F(VideoRendererImplTest, RenderingStopsAfterFirstFrame) {
   InitializeWithLowDelay(true);
   QueueFrames("0");
 
-  EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   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);
   EXPECT_CALL(mock_cb_, OnEnded()).Times(0);
 
   {
-    SCOPED_TRACE("Waiting for sink to stop.");
+    SCOPED_TRACE("Waiting for first frame to be painted.");
     WaitableMessageLoopEvent event;
 
-    null_video_sink_->set_background_render(true);
-    null_video_sink_->set_stop_cb(event.GetClosure());
+    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)))
+        .WillOnce(RunClosure(event.GetClosure()));
     StartPlayingFrom(0);
 
     EXPECT_TRUE(IsReadPending());
     SatisfyPendingReadWithEndOfStream();
 
     event.RunAndWait();
   }
 
   Destroy();
 }
 
 // Verifies that the sink is stopped after rendering the first frame if
-// playback ha started.
+// playback has started.
 TEST_F(VideoRendererImplTest, RenderingStopsAfterOneFrameWithEOS) {
   InitializeWithLowDelay(true);
   QueueFrames("0");
 
-  EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
+  EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0))).Times(2);
   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());
@@ skipping 19 matching lines @@
 
   // Start the sink and wait for the first callback.  Set statistics to a non
   // zero value, once we have some decoded frames they should be overwritten.
   PipelineStatistics last_pipeline_statistics;
   last_pipeline_statistics.video_frames_dropped = 1;
   {
     WaitableMessageLoopEvent event;
     EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
     EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)))
         .WillOnce(RunClosure(event.GetClosure()));
-    EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_))
-        .WillRepeatedly(SaveArg<0>(&last_pipeline_statistics));
     EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
     EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
     StartPlayingFrom(0);
     event.RunAndWait();
     Mock::VerifyAndClearExpectations(&mock_cb_);
-    EXPECT_EQ(0u, last_pipeline_statistics.video_frames_dropped);
-    EXPECT_EQ(460800, last_pipeline_statistics.video_memory_usage);
   }
 
   // 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,
   // 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();
 
   // 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(460800, last_pipeline_statistics.video_memory_usage);
+  EXPECT_EQ(115200, last_pipeline_statistics.video_memory_usage);
 
   AdvanceTimeInMs(30);
   WaitForEnded();
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, StartPlayingFromThenFlushThenEOS) {
   Initialize();
   QueueFrames("0 30 60 90");
 
@@ skipping 221 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