Refactor VideoRendererImpl to use VideoFrameScheduler.

media/filters/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/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/timer/timer.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/test_helpers.h"
 #include "media/base/video_frame.h"
+#include "media/filters/clockless_video_frame_scheduler.h"
+#include "media/filters/video_frame_scheduler_impl.h"
 #include "media/filters/video_renderer_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::NiceMock;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 namespace media {
 
 static const int kFrameDurationInMs = 10;
 static const int kVideoDurationInMs = kFrameDurationInMs * 100;
 
 class VideoRendererImplTest : public ::testing::Test {
  public:
   VideoRendererImplTest()
       : decoder_(new MockVideoDecoder()),
         demuxer_stream_(DemuxerStream::VIDEO) {
     ScopedVector<VideoDecoder> decoders;
     decoders.push_back(decoder_);
 
     renderer_.reset(new VideoRendererImpl(
         message_loop_.message_loop_proxy(),
+        scoped_ptr<VideoFrameScheduler>(
+#if 1
+            new ClocklessVideoFrameScheduler(base::Bind(
+                &VideoRendererImplTest::OnPaint, base::Unretained(this)))),
+#else
+            new VideoFrameSchedulerImpl(
+                message_loop_.message_loop_proxy(),
+                base::Bind(&VideoRendererImplTest::OnPaint,
+                           base::Unretained(this)))),
+#endif
         decoders.Pass(),
-        media::SetDecryptorReadyCB(),
-        base::Bind(&VideoRendererImplTest::OnPaint, base::Unretained(this)),
-        true));
+        media::SetDecryptorReadyCB()));
 
     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,
                                        DecoderBuffer::CreateEOSBuffer()));
     EXPECT_CALL(*decoder_, Stop())
         .WillRepeatedly(Invoke(this, &VideoRendererImplTest::StopRequested));
     EXPECT_CALL(statistics_cb_object_, OnStatistics(_))
@@ skipping 19 matching lines @@
         .WillRepeatedly(Invoke(this, &VideoRendererImplTest::FrameRequested));
 
     EXPECT_CALL(*decoder_, Reset(_))
         .WillRepeatedly(Invoke(this, &VideoRendererImplTest::FlushRequested));
 
     InSequence s;
 
     EXPECT_CALL(*decoder_, Initialize(_, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
 
-    // Set playback rate before anything else happens.
-    renderer_->SetPlaybackRate(1.0f);
-
     // Initialize, we shouldn't have any reads.
     InitializeRenderer(PIPELINE_OK);
 
     // Start prerolling.
     QueuePrerollFrames(0);
     Preroll(0, PIPELINE_OK);
   }
 
   void InitializeRenderer(PipelineStatus expected) {
     SCOPED_TRACE(base::StringPrintf("InitializeRenderer(%d)", expected));
@@ skipping 10 matching lines @@
                    base::Unretained(&statistics_cb_object_)),
         base::Bind(&VideoRendererImplTest::OnTimeUpdate,
                    base::Unretained(this)),
         ended_event_.GetClosure(),
         error_event_.GetPipelineStatusCB(),
         base::Bind(&VideoRendererImplTest::GetTime, base::Unretained(this)),
         base::Bind(&VideoRendererImplTest::GetDuration,
                    base::Unretained(this)));
   }
 
+  void SetPlaybackRate(float playback_rate) {
+    SCOPED_TRACE(base::StringPrintf("SetPlaybackRate(%f)", playback_rate));
+    renderer_->SetPlaybackRate(playback_rate);
+  }
+
   void Play() {
     SCOPED_TRACE("Play()");
     WaitableMessageLoopEvent event;
     renderer_->Play(event.GetClosure());
     event.RunAndWait();
   }
 
   void Preroll(int timestamp_ms, PipelineStatus expected) {
     SCOPED_TRACE(base::StringPrintf("Preroll(%d, %d)", timestamp_ms, expected));
     WaitableMessageLoopEvent event;
@@ skipping 74 matching lines @@
       QueueNextFrame();
     }
 
     // Queue the frame at |timestamp| plus additional ones for prerolling.
     for (int i = 0; i < limits::kMaxVideoFrames; ++i) {
       QueueNextFrame();
     }
   }
 
   void ResetCurrentFrame() {
-    base::AutoLock l(lock_);
     current_frame_ = NULL;
   }
 
   scoped_refptr<VideoFrame> GetCurrentFrame() {
-    base::AutoLock l(lock_);
     return current_frame_;
   }
 
   int GetCurrentTimestampInMs() {
     scoped_refptr<VideoFrame> frame = GetCurrentFrame();
-    if (!frame.get())
+    if (!current_frame_)
       return -1;
-    return frame->timestamp().InMilliseconds();
+    return current_frame_->timestamp().InMilliseconds();
   }
 
   void WaitForError(PipelineStatus expected) {
     SCOPED_TRACE(base::StringPrintf("WaitForError(%d)", expected));
     error_event_.RunAndWaitForStatus(expected);
   }
 
   void WaitForEnded() {
     SCOPED_TRACE("WaitForEnded()");
     ended_event_.RunAndWait();
@@ skipping 18 matching lines @@
     CHECK(!read_cb_.is_null());
     CHECK(!decode_results_.empty());
 
     base::Closure closure = base::Bind(
         read_cb_, decode_results_.front().first,
         decode_results_.front().second);
 
     read_cb_.Reset();
     decode_results_.pop_front();
 
+    LOG(ERROR) << __FUNCTION__;
+
     message_loop_.PostTask(FROM_HERE, closure);
   }
 
   void AdvanceTimeInMs(int time_ms) {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
-    base::AutoLock l(lock_);
     time_ += base::TimeDelta::FromMilliseconds(time_ms);
     DCHECK_LE(time_.InMicroseconds(), duration_.InMicroseconds());
   }
 
  protected:
   // Fixture members.
   scoped_ptr<VideoRendererImpl> renderer_;
   MockVideoDecoder* decoder_;  // Owned by |renderer_|.
   NiceMock<MockDemuxerStream> demuxer_stream_;
   MockStatisticsCB statistics_cb_object_;
 
  private:
   base::TimeDelta GetTime() {
-    base::AutoLock l(lock_);
     return time_;
   }
 
   base::TimeDelta GetDuration() {
     return duration_;
   }
 
   void OnPaint(const scoped_refptr<VideoFrame>& frame) {
-    base::AutoLock l(lock_);
+    LOG(ERROR) << __FUNCTION__ << " ts=" << frame->timestamp().InMicroseconds();
     current_frame_ = frame;
   }
 
   void FrameRequested(const scoped_refptr<DecoderBuffer>& buffer,
                       const VideoDecoder::DecodeCB& read_cb) {
+    LOG(ERROR) << __FUNCTION__;
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     CHECK(read_cb_.is_null());
     read_cb_ = read_cb;
 
     // Wake up WaitForPendingRead() if needed.
     if (!wait_for_pending_read_cb_.is_null())
       base::ResetAndReturn(&wait_for_pending_read_cb_).Run();
 
     if (decode_results_.empty())
       return;
@@ skipping 16 matching lines @@
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     decode_results_.clear();
     if (!read_cb_.is_null()) {
       QueueAbortedRead();
       SatisfyPendingRead();
     }
   }
 
   base::MessageLoop message_loop_;
 
-  // Used to protect |time_| and |current_frame_|.
-  base::Lock lock_;
   base::TimeDelta time_;
   scoped_refptr<VideoFrame> current_frame_;
 
   // Used for satisfying reads.
   VideoDecoder::DecodeCB read_cb_;
   base::TimeDelta next_frame_timestamp_;
   base::TimeDelta duration_;
 
   WaitableMessageLoopEvent error_event_;
   WaitableMessageLoopEvent ended_event_;
@@ skipping 46 matching lines @@
 }
 
 TEST_F(VideoRendererImplTest, Play) {
   Initialize();
   Play();
   Shutdown();
 }
 
 TEST_F(VideoRendererImplTest, EndOfStream_DefaultFrameDuration) {
   Initialize();
+  SetPlaybackRate(1.0);  // Can't reach end of stream with zero playback rate.
   Play();
 
   // Verify that the ended callback fires when the default last frame duration
   // has elapsed.
   int end_timestamp = kFrameDurationInMs * limits::kMaxVideoFrames +
       VideoRendererImpl::kMaxLastFrameDuration().InMilliseconds();
   EXPECT_LT(end_timestamp, kVideoDurationInMs);
 
   QueueEndOfStream();
   AdvanceTimeInMs(end_timestamp);
   WaitForEnded();
 
   Shutdown();
 }
 
 TEST_F(VideoRendererImplTest, EndOfStream_ClipDuration) {
   int duration = kVideoDurationInMs + kFrameDurationInMs / 2;
   InitializeWithDuration(duration);
+  SetPlaybackRate(1.0);  // Can't reach end of stream with zero playback rate.
   Play();
 
   // Render all frames except for the last |limits::kMaxVideoFrames| frames
   // and deliver all the frames between the start and |duration|. The preroll
   // inside Initialize() makes this a little confusing, but |timestamp| is
   // the current render time and QueueNextFrame() delivers a frame with a
   // timestamp that is |timestamp| + limits::kMaxVideoFrames *
   // kFrameDurationInMs.
   int timestamp = kFrameDurationInMs;
   int end_timestamp = duration - limits::kMaxVideoFrames * kFrameDurationInMs;
   for (; timestamp < end_timestamp; timestamp += kFrameDurationInMs) {
     QueueNextFrame();
   }
 
   // Queue the end of stream frame and wait for the last frame to be rendered.
   QueueEndOfStream();
+  SatisfyPendingRead();
   AdvanceTimeInMs(duration);
   WaitForEnded();
 
   Shutdown();
 }
 
 TEST_F(VideoRendererImplTest, DecodeError_Playing) {
   Initialize();
+  SetPlaybackRate(1.0);
   Play();
 
   QueueDecodeError();
-  AdvanceTimeInMs(kVideoDurationInMs);
+  SatisfyPendingRead();
+  // AdvanceTimeInMs(kVideoDurationInMs);
   WaitForError(PIPELINE_ERROR_DECODE);
   Shutdown();
 }
 
 TEST_F(VideoRendererImplTest, DecodeError_DuringPreroll) {
   Initialize();
   Pause();
   Flush();
 
   QueueDecodeError();
@@ skipping 29 matching lines @@
   Flush();
   QueuePrerollFrames(kFrameDurationInMs * 6);
 
   Preroll(kFrameDurationInMs * 6 + 1, PIPELINE_OK);
   EXPECT_EQ(kFrameDurationInMs * 6, GetCurrentTimestampInMs());
   Shutdown();
 }
 
 TEST_F(VideoRendererImplTest, PlayAfterPreroll) {
   Initialize();
+  SetPlaybackRate(1.0);
   Pause();
   Flush();
   QueuePrerollFrames(kFrameDurationInMs * 4);
 
   Preroll(kFrameDurationInMs * 4, PIPELINE_OK);
   EXPECT_EQ(kFrameDurationInMs * 4, GetCurrentTimestampInMs());
 
   Play();
   // Advance time past prerolled time to trigger a Read().
   AdvanceTimeInMs(5 * kFrameDurationInMs);
@@ skipping 37 matching lines @@
   // preroll even after the first frame is painted.
   QueueNextFrame();
   Play();
 
   // Simulate a Pause/Preroll/Play rebuffer sequence.
   Pause();
 
   WaitableMessageLoopEvent event;
   renderer_->Preroll(kNoTimestamp(),
                      event.GetPipelineStatusCB());
-
+  SatisfyPendingRead();
   event.RunAndWaitForStatus(PIPELINE_OK);
 
   Play();
 
   Shutdown();
 }
 
 TEST_F(VideoRendererImplTest, GetCurrentFrame_Initialized) {
   Initialize();
   EXPECT_TRUE(GetCurrentFrame().get());  // Due to prerolling.
@@ skipping 23 matching lines @@
   // Frame shouldn't be updated.
   ResetCurrentFrame();
   Flush();
   EXPECT_FALSE(GetCurrentFrame().get());
 
   Shutdown();
 }
 
 TEST_F(VideoRendererImplTest, GetCurrentFrame_EndOfStream) {
   Initialize();
+  SetPlaybackRate(1.0);  // Can't reach end of stream with zero playback rate.
   Play();
   Pause();
   Flush();
 
   // Preroll only end of stream frames.
   QueueEndOfStream();
 
   // Frame shouldn't be updated.
   ResetCurrentFrame();
   Preroll(0, PIPELINE_OK);
@@ skipping 86 matching lines @@
   InSequence s;
 
   EXPECT_CALL(*decoder_, Initialize(_, _))
       .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
   InitializeRenderer(DECODER_ERROR_NOT_SUPPORTED);
 
   Stop();
 }
 
 }  // namespace media