Introduce NullVideoSink for test classes.

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"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/base/data_buffer.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/limits.h"
 #include "media/base/mock_filters.h"
+#include "media/base/null_video_sink.h"
 #include "media/base/test_helpers.h"
 #include "media/base/video_frame.h"
 #include "media/renderers/video_renderer_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::Invoke;
 using ::testing::Mock;
 using ::testing::NiceMock;
@@ skipping 14 matching lines @@
 
 class VideoRendererImplTest : public ::testing::Test {
  public:
   VideoRendererImplTest()
       : tick_clock_(new base::SimpleTestTickClock()),
         decoder_(new MockVideoDecoder()),
         demuxer_stream_(DemuxerStream::VIDEO) {
     ScopedVector<VideoDecoder> decoders;
     decoders.push_back(decoder_);
 
-    renderer_.reset(new VideoRendererImpl(message_loop_.message_loop_proxy(),
-                                          &mock_cb_,
-                                          decoders.Pass(), true,
-                                          new MediaLog()));
+    // 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()));
+
     renderer_->SetTickClockForTesting(scoped_ptr<base::TickClock>(tick_clock_));
+    null_video_sink_->set_tick_clock_for_testing(tick_clock_);
 
     // 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 187 matching lines @@
   }
 
  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.
-  // TODO(dalecurtis): Mocks won't be useful for the new rendering path, we'll
-  // need fake callback generators like we have for the audio path.
-  // http://crbug.com/473424
-  class MockCB : public VideoRendererSink {
+  class MockCB {
    public:
-    MOCK_METHOD1(Start, void(VideoRendererSink::RenderCallback*));
-    MOCK_METHOD0(Stop, void());
-    MOCK_METHOD1(PaintFrameUsingOldRenderingPath,
-                 void(const scoped_refptr<VideoFrame>&));
+    MOCK_METHOD1(FrameReceived, void(const scoped_refptr<VideoFrame>&));
     MOCK_METHOD1(BufferingStateChange, void(BufferingState));
   };
   StrictMock<MockCB> mock_cb_;
 
+  // Must be destroyed before |renderer_| since they share |tick_clock_|.
+  scoped_ptr<NullVideoSink> null_video_sink_;
+
  private:
   base::TimeTicks GetWallClockTime(base::TimeDelta time) {
     base::AutoLock l(lock_);
     return tick_clock_->NowTicks() + (time - time_);
   }
 
   void DecodeRequested(const scoped_refptr<DecoderBuffer>& buffer,
                        const VideoDecoder::DecodeCB& decode_cb) {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     CHECK(decode_cb_.is_null());
@@ skipping 57 matching lines @@
 }
 
 TEST_F(VideoRendererImplTest, Initialize) {
   Initialize();
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, InitializeAndStartPlayingFrom) {
   Initialize();
   QueueFrames("0 10 20 30");
-  EXPECT_CALL(mock_cb_, PaintFrameUsingOldRenderingPath(HasTimestamp(0)));
+  EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(0);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, DestroyWhileInitializing) {
   CallInitialize(NewExpectedStatusCB(PIPELINE_ERROR_ABORT), false, PIPELINE_OK);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, DestroyWhileFlushing) {
   Initialize();
   QueueFrames("0 10 20 30");
-  EXPECT_CALL(mock_cb_, PaintFrameUsingOldRenderingPath(HasTimestamp(0)));
+  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) {
   Initialize();
   QueueFrames("0 10 20 30");
-  EXPECT_CALL(mock_cb_, PaintFrameUsingOldRenderingPath(HasTimestamp(0)));
+  EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(0);
   Destroy();
 }
 
 TEST_F(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) {
   Initialize();
   QueueFrames("0 10 20 30");
-  EXPECT_CALL(mock_cb_, PaintFrameUsingOldRenderingPath(HasTimestamp(0)));
+  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) {
   Initialize();
   QueueFrames("error");
   StartPlayingFrom(0);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, StartPlayingFrom_Exact) {
   Initialize();
   QueueFrames("50 60 70 80 90");
 
-  EXPECT_CALL(mock_cb_, PaintFrameUsingOldRenderingPath(HasTimestamp(60)));
+  EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(60)));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(60);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, StartPlayingFrom_RightBefore) {
   Initialize();
   QueueFrames("50 60 70 80 90");
 
-  EXPECT_CALL(mock_cb_, PaintFrameUsingOldRenderingPath(HasTimestamp(50)));
+  EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(50)));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(59);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, StartPlayingFrom_RightAfter) {
   Initialize();
   QueueFrames("50 60 70 80 90");
 
-  EXPECT_CALL(mock_cb_, PaintFrameUsingOldRenderingPath(HasTimestamp(60)));
+  EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(60)));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(61);
   Destroy();
 }
 
 TEST_F(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_, PaintFrameUsingOldRenderingPath(HasTimestamp(0)));
+  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();
 
   WaitableMessageLoopEvent event;
-  EXPECT_CALL(mock_cb_, PaintFrameUsingOldRenderingPath(HasTimestamp(10)))
+  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) {
   Initialize();
   QueueFrames("0 10 20 30");
-  EXPECT_CALL(mock_cb_, PaintFrameUsingOldRenderingPath(HasTimestamp(0)));
+  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) {
   InitializeRenderer(DECODER_ERROR_NOT_SUPPORTED, false);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, Underflow) {
   Initialize();
   QueueFrames("0 10 20 30");
 
   {
     WaitableMessageLoopEvent event;
-    EXPECT_CALL(mock_cb_, PaintFrameUsingOldRenderingPath(HasTimestamp(0)));
+    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_);
   }
 
   // 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_, PaintFrameUsingOldRenderingPath(HasTimestamp(10)))
+    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(10)))
         .Times(0);
-    EXPECT_CALL(mock_cb_, PaintFrameUsingOldRenderingPath(HasTimestamp(20)))
+    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(20)))
         .Times(0);
-    EXPECT_CALL(mock_cb_, PaintFrameUsingOldRenderingPath(HasTimestamp(30)))
+    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(30)))
         .WillOnce(RunClosure(event.GetClosure()));
     AdvanceTimeInMs(31);
     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");
@@ skipping 13 matching lines @@
         .WillOnce(RunClosure(event.GetClosure()));
     SatisfyPendingReadWithEndOfStream();
     event.RunAndWait();
   }
 
   WaitForEnded();
   Destroy();
 }
 
 }  // namespace media