Rename VideoRenderer::OnTimeStateChanged to OnTime{Progressing,Stopped}

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 286 matching lines @@
       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();
       Mock::VerifyAndClearExpectations(&mock_cb_);
     }
 
-    renderer_->OnTimeStateChanged(true);
+    renderer_->TimeStartedProgressing();
 
     // 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;
 
       // Note: Starting the TimeSource will cause the old VideoRendererImpl to
       // start rendering frames on its own thread, so the first frame may be
@@ skipping 17 matching lines @@
       SCOPED_TRACE("Waiting for BUFFERING_HAVE_NOTHING");
       WaitableMessageLoopEvent event;
       EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
           .WillOnce(RunClosure(event.GetClosure()));
       AdvanceTimeInMs(30);
       event.RunAndWait();
       Mock::VerifyAndClearExpectations(&mock_cb_);
     }
 
     // Simulate delayed buffering state callbacks.
-    renderer_->OnTimeStateChanged(false);
-    renderer_->OnTimeStateChanged(true);
+    renderer_->TimeStoppedProgressing();
+    renderer_->TimeStartedProgressing();
 
     // Receiving end of stream should signal having enough.
     {
       SCOPED_TRACE("Waiting for BUFFERING_HAVE_ENOUGH");
       WaitableMessageLoopEvent event;
       EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
       EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
           .WillOnce(RunClosure(event.GetClosure()));
       EXPECT_CALL(mock_cb_, OnEnded());
       SatisfyPendingDecodeWithEndOfStream();
@@ skipping 15 matching lines @@
       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();
       Mock::VerifyAndClearExpectations(&mock_cb_);
     }
 
-    renderer_->OnTimeStateChanged(true);
+    renderer_->TimeStartedProgressing();
     time_source_.StartTicking();
 
     // Advance time, this should cause have nothing to be signaled.
     {
       SCOPED_TRACE("Waiting for BUFFERING_HAVE_NOTHING");
       WaitableMessageLoopEvent event;
       EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
           .WillOnce(RunClosure(event.GetClosure()));
       EXPECT_CALL(mock_cb_, FrameReceived(HasTimestampMatcher(20))).Times(1);
       EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
       AdvanceTimeInMs(20);
       event.RunAndWait();
       Mock::VerifyAndClearExpectations(&mock_cb_);
     }
 
     AdvanceTimeInMs(59);
     EXPECT_EQ(3u, renderer_->frames_queued_for_testing());
     time_source_.StopTicking();
-    renderer_->OnTimeStateChanged(false);
+    renderer_->TimeStoppedProgressing();
     EXPECT_EQ(0u, renderer_->frames_queued_for_testing());
     ASSERT_TRUE(IsReadPending());
 
     // Queue some frames, satisfy reads, and make sure expired frames are gone
     // when the renderer paints the first frame.
     {
       SCOPED_TRACE("Waiting for BUFFERING_HAVE_ENOUGH");
       WaitableMessageLoopEvent event;
       EXPECT_CALL(mock_cb_, FrameReceived(HasTimestampMatcher(80))).Times(1);
       EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
@@ skipping 110 matching lines @@
   {
     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());
     SatisfyPendingDecodeWithEndOfStream();
     event.RunAndWait();
   }
   // Firing a time state changed to true should be ignored...
-  renderer_->OnTimeStateChanged(true);
+  renderer_->TimeStartedProgressing();
   EXPECT_FALSE(null_video_sink_->is_started());
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, DestroyWhileInitializing) {
   CallInitialize(NewExpectedStatusCB(PIPELINE_ERROR_ABORT), false, PIPELINE_OK);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, DestroyWhileFlushing) {
@@ skipping 65 matching lines @@
   // In that case, when we run out of the frames, BUFFERING_HAVE_NOTHING will
   // be called.
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
       .Times(testing::AtMost(1));
   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);
+  renderer_->TimeStartedProgressing();
   time_source_.StartTicking();
   AdvanceTimeInMs(10);
 
   QueueFrames("error");
   SatisfyPendingDecode();
   WaitForError(PIPELINE_ERROR_DECODE);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, DecodeError_DuringStartPlayingFrom) {
@@ skipping 56 matching lines @@
   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");
   SatisfyPendingDecode();
 
-  renderer_->OnTimeStateChanged(true);
+  renderer_->TimeStartedProgressing();
   time_source_.StartTicking();
 
   WaitableMessageLoopEvent event;
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestampMatcher(20)))
       .WillOnce(RunClosure(event.GetClosure()));
   AdvanceTimeInMs(20);
   event.RunAndWait();
 
   Destroy();
 }
@@ skipping 83 matching lines @@
   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);
+    renderer_->TimeStartedProgressing();
 
     EXPECT_TRUE(IsReadPending());
     SatisfyPendingDecodeWithEndOfStream();
     WaitForEnded();
 
-    renderer_->OnTimeStateChanged(false);
+    renderer_->TimeStoppedProgressing();
     event.RunAndWait();
   }
 
   Destroy();
 }
 
 // Tests the case where the video started and received a single Render() call,
 // then the video was put into the background.
 TEST_F(VideoRendererImplTest, RenderingStartedThenStopped) {
   Initialize();
@@ skipping 27 matching lines @@
   EXPECT_EQ(115200, 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 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));
-  renderer_->OnTimeStateChanged(true);
+  renderer_->TimeStartedProgressing();
   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(HasTimestampMatcher(90)));
   WaitForPendingDecode();
   SatisfyPendingDecodeWithEndOfStream();
@@ skipping 19 matching lines @@
     EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
     StartPlayingFrom(0);
     event.RunAndWait();
   }
 
   {
     SCOPED_TRACE("Waiting for BUFFERING_HAVE_NOTHING");
     WaitableMessageLoopEvent event;
     EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
         .WillOnce(RunClosure(event.GetClosure()));
-    renderer_->OnTimeStateChanged(true);
+    renderer_->TimeStartedProgressing();
     time_source_.StartTicking();
     event.RunAndWait();
   }
 
   WaitForPendingDecode();
 
   // Jump time far enough forward that no frames are valid.
-  renderer_->OnTimeStateChanged(false);
+  renderer_->TimeStoppedProgressing();
   AdvanceTimeInMs(1000);
   time_source_.StopTicking();
 
   // Providing the end of stream packet should remove all frames and exit.
   SatisfyPendingDecodeWithEndOfStream();
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   WaitForEnded();
   Destroy();
 }
 
@@ skipping 10 matching lines @@
     EXPECT_CALL(mock_cb_, FrameReceived(_)).Times(AnyNumber());
     EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
     EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
     EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
     StartPlayingFrom(0);
     event.RunAndWait();
   }
 
   null_video_sink_->set_background_render(true);
   time_source_.StartTicking();
-  renderer_->OnTimeStateChanged(true);
+  renderer_->TimeStartedProgressing();
   WaitForPendingDecode();
-  renderer_->OnTimeStateChanged(false);
+  renderer_->TimeStoppedProgressing();
 
   // Jump time far enough forward that no frames are valid.
   AdvanceTimeInMs(1000);
 
   {
     SCOPED_TRACE("Waiting for BUFFERING_HAVE_NOTHING");
     WaitableMessageLoopEvent event;
     EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
         .WillOnce(RunClosure(event.GetClosure()));
     QueueFrames("120");
     SatisfyPendingDecode();
     event.RunAndWait();
   }
 
   // This should do nothing.
-  renderer_->OnTimeStateChanged(true);
+  renderer_->TimeStartedProgressing();
 
   // Providing the end of stream packet should remove all frames and exit.
   SatisfyPendingDecodeWithEndOfStream();
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   WaitForEnded();
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, StartPlayingFromThenFlushThenEOS) {
   Initialize();
@@ skipping 36 matching lines @@
   null_video_sink_->set_background_render(true);
   QueueFrames("0 10 20");
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
       .Times(testing::AtMost(1));
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestampMatcher(0)));
   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);
+  renderer_->TimeStartedProgressing();
   time_source_.StartTicking();
 
   WaitableMessageLoopEvent event;
   // Frame "10" should not have been expired.
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestampMatcher(10)))
       .WillOnce(RunClosure(event.GetClosure()));
   AdvanceTimeInMs(10);
   event.RunAndWait();
 
   Destroy();
@@ skipping 24 matching lines @@
 
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
 
   {
     // Callback is fired for the first frame.
     EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(initial_size));
     EXPECT_CALL(mock_cb_, FrameReceived(HasTimestampMatcher(0)));
     StartPlayingFrom(0);
-    renderer_->OnTimeStateChanged(true);
+    renderer_->TimeStartedProgressing();
     time_source_.StartTicking();
   }
   {
     // Callback should be fired once when switching to the larger size.
     EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(larger_size));
     WaitableMessageLoopEvent event;
     EXPECT_CALL(mock_cb_, FrameReceived(HasTimestampMatcher(10)))
         .WillOnce(RunClosure(event.GetClosure()));
     AdvanceTimeInMs(10);
     event.RunAndWait();
@@ skipping 45 matching lines @@
 
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(frame_size)).Times(1);
 
   {
     // Callback is fired for the first frame.
     EXPECT_CALL(mock_cb_, OnVideoOpacityChange(false));
     EXPECT_CALL(mock_cb_, FrameReceived(HasTimestampMatcher(0)));
     StartPlayingFrom(0);
-    renderer_->OnTimeStateChanged(true);
+    renderer_->TimeStartedProgressing();
     time_source_.StartTicking();
   }
   {
     // Callback is not fired because opacity does not change.
     WaitableMessageLoopEvent event;
     EXPECT_CALL(mock_cb_, FrameReceived(HasTimestampMatcher(10)))
         .WillOnce(RunClosure(event.GetClosure()));
     AdvanceTimeInMs(10);
     event.RunAndWait();
   }
@@ skipping 55 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