Fix underflow and av/sync issues in low delay and stall presence.

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 <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 261 matching lines @@
     time_ += base::TimeDelta::FromMilliseconds(time_ms);
     time_source_.StopTicking();
     time_source_.SetMediaTime(time_);
     time_source_.StartTicking();
   }
 
   bool has_ended() const {
     return ended_event_.is_signaled();
   }
 
+  enum class UnderflowTestType { kNormal, kLowDelay, kCantReadWithoutStalling };

[xhwang, 2016/04/14 21:28:00]

nit: use UPPER_CASE style for enums?

+  void BasicUnderflowTest(UnderflowTestType type) {
+    InitializeWithLowDelay(type == UnderflowTestType::kLowDelay);
+    if (type == UnderflowTestType::kCantReadWithoutStalling)
+      ON_CALL(*decoder_, CanReadWithoutStalling()).WillByDefault(Return(false));
+
+    QueueFrames("0 30 60 90");
+
+    {
+      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;
+
+      // Note: Starting the TimeSource will cause the old VideoRendererImpl to
+      // start rendering frames on its own thread, so the first frame may be
+      // received.
+      time_source_.StartTicking();
+      EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(30))).Times(0);
+
+      EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(60))).Times(0);
+      EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(90)))
+          .WillOnce(RunClosure(event.GetClosure()));
+      AdvanceTimeInMs(91);
+
+      event.RunAndWait();
+      Mock::VerifyAndClearExpectations(&mock_cb_);
+    }
+
+    // Advance time more. Now we should signal having nothing. And put
+    // the last frame up for display.
+    {
+      SCOPED_TRACE("Waiting for BUFFERING_HAVE_NOTHING");
+      WaitableMessageLoopEvent event;
+      EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_NOTHING))
+          .WillOnce(RunClosure(event.GetClosure()));
+      AdvanceTimeInMs(30);
+      event.RunAndWait();
+      Mock::VerifyAndClearExpectations(&mock_cb_);
+    }
+
+    // Receiving end of stream should signal having enough.
+    {
+      SCOPED_TRACE("Waiting for BUFFERING_HAVE_ENOUGH");
+      WaitableMessageLoopEvent event;
+      EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
+          .WillOnce(RunClosure(event.GetClosure()));
+      SatisfyPendingReadWithEndOfStream();
+      event.RunAndWait();
+    }
+
+    WaitForEnded();
+    Destroy();
+  }
+
+  void UnderflowRecoveryTest(UnderflowTestType type) {
+    InitializeWithLowDelay(type == UnderflowTestType::kLowDelay);
+    if (type == UnderflowTestType::kCantReadWithoutStalling)
+      ON_CALL(*decoder_, CanReadWithoutStalling()).WillByDefault(Return(false));
+
+    QueueFrames("0 20 40 60");
+    {
+      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);
+    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_, BufferingStateChange(BUFFERING_HAVE_NOTHING))
+          .WillOnce(RunClosure(event.GetClosure()));
+      EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(20))).Times(1);
+      AdvanceTimeInMs(20);
+      event.RunAndWait();
+      Mock::VerifyAndClearExpectations(&mock_cb_);
+    }
+
+    AdvanceTimeInMs(59);
+    EXPECT_EQ(3u, renderer_->frames_queued_for_testing());
+    time_source_.StopTicking();
+    renderer_->OnTimeStateChanged(false);
+    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(HasTimestamp(80))).Times(1);
+      EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
+          .WillOnce(RunClosure(event.GetClosure()));
+      if (type == UnderflowTestType::kNormal)
+        QueueFrames("80 100 120 140 160");
+      else
+        QueueFrames("40 60 80");
+      SatisfyPendingRead();
+      event.RunAndWait();
+    }
+
+    Destroy();
+  }
+
  protected:
   // Fixture members.
   scoped_ptr<VideoRendererImpl> renderer_;
   base::SimpleTestTickClock* tick_clock_;  // Owned by |renderer_|.
   NiceMock<MockVideoDecoder>* decoder_;    // Owned by |renderer_|.
   NiceMock<MockDemuxerStream> demuxer_stream_;
 
   // Use StrictMock<T> to catch missing/extra callbacks.
   class MockCB {
    public:
@@ skipping 244 matching lines @@
 
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, VideoDecoder_InitFailure) {
   InitializeRenderer(false, false);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, Underflow) {
-  Initialize();
-  QueueFrames("0 30 60 90");
+  BasicUnderflowTest(UnderflowTestType::kNormal);
+}
 
-  {
-    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_);
-  }
+TEST_F(VideoRendererImplTest, Underflow_LowDelay) {
+  BasicUnderflowTest(UnderflowTestType::kLowDelay);
+}
 
-  renderer_->OnTimeStateChanged(true);
+TEST_F(VideoRendererImplTest, Underflow_CantReadWithoutStalling) {
+  BasicUnderflowTest(UnderflowTestType::kCantReadWithoutStalling);
+}
 
-  // 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;
+TEST_F(VideoRendererImplTest, UnderflowRecovery) {
+  UnderflowRecoveryTest(UnderflowTestType::kNormal);
+}
 
-    // Note: Starting the TimeSource will cause the old VideoRendererImpl to
-    // start rendering frames on its own thread, so the first frame may be
-    // received.
-    time_source_.StartTicking();
-    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(30))).Times(0);
+TEST_F(VideoRendererImplTest, UnderflowRecovery_LowDelay) {
+  UnderflowRecoveryTest(UnderflowTestType::kLowDelay);
+}
 
-    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(60))).Times(0);
-    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(90)))
-        .WillOnce(RunClosure(event.GetClosure()));
-    AdvanceTimeInMs(91);
-
-    event.RunAndWait();
-    Mock::VerifyAndClearExpectations(&mock_cb_);
-  }
-
-  // Advance time more. Now we should signal having nothing. And put
-  // the last frame up for display.
-  {
-    SCOPED_TRACE("Waiting for BUFFERING_HAVE_NOTHING");
-    WaitableMessageLoopEvent event;
-    EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_NOTHING))
-        .WillOnce(RunClosure(event.GetClosure()));
-    AdvanceTimeInMs(30);
-    event.RunAndWait();
-    Mock::VerifyAndClearExpectations(&mock_cb_);
-  }
-
-  // Receiving end of stream should signal having enough.
-  {
-    SCOPED_TRACE("Waiting for BUFFERING_HAVE_ENOUGH");
-    WaitableMessageLoopEvent event;
-    EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
-        .WillOnce(RunClosure(event.GetClosure()));
-    SatisfyPendingReadWithEndOfStream();
-    event.RunAndWait();
-  }
-
-  WaitForEnded();
-  Destroy();
+TEST_F(VideoRendererImplTest, UnderflowRecovery_CantReadWithoutStalling) {
+  UnderflowRecoveryTest(UnderflowTestType::kCantReadWithoutStalling);
 }
 
 // Verifies that the sink is stopped after rendering the first frame if
 // playback hasn't started.
 TEST_F(VideoRendererImplTest, RenderingStopsAfterFirstFrame) {
   InitializeWithLowDelay(true);
   QueueFrames("0");
 
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
@@ skipping 186 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