Switch GetWallClockTime to using vectors for input and output.

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/base/wall_clock_time_source.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;
 using ::testing::Return;
 using ::testing::SaveArg;
@@ skipping 24 matching lines @@
         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()));
     if (!GetParam())
       renderer_->disable_new_video_renderer_for_testing();
     renderer_->SetTickClockForTesting(scoped_ptr<base::TickClock>(tick_clock_));
     null_video_sink_->set_tick_clock_for_testing(tick_clock_);
+    time_source_.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 22 matching lines @@
     WaitableMessageLoopEvent event;
     CallInitialize(event.GetPipelineStatusCB(), low_delay, expected);
     event.RunAndWaitForStatus(expected);
   }
 
   void CallInitialize(const PipelineStatusCB& status_cb,
                       bool low_delay,
                       PipelineStatus decoder_status) {
     if (low_delay)
       demuxer_stream_.set_liveness(DemuxerStream::LIVENESS_LIVE);
-    EXPECT_CALL(*decoder_, Initialize(_, _, _, _)).WillOnce(
-        DoAll(SaveArg<3>(&output_cb_), RunCallback<2>(decoder_status)));
+    EXPECT_CALL(*decoder_, Initialize(_, _, _, _))
+        .WillOnce(
+            DoAll(SaveArg<3>(&output_cb_), RunCallback<2>(decoder_status)));
     EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
     renderer_->Initialize(
         &demuxer_stream_, status_cb, media::SetDecryptorReadyCB(),
         base::Bind(&VideoRendererImplTest::OnStatisticsUpdate,
                    base::Unretained(this)),
         base::Bind(&StrictMock<MockCB>::BufferingStateChange,
                    base::Unretained(&mock_cb_)),
         ended_event_.GetClosure(), error_event_.GetPipelineStatusCB(),
-        base::Bind(&VideoRendererImplTest::GetWallClockTime,
-                   base::Unretained(this)),
+        base::Bind(&WallClockTimeSource::GetWallClockTimes,
+                   base::Unretained(&time_source_)),
         base::Bind(&VideoRendererImplTest::OnWaitingForDecryptionKey,
                    base::Unretained(this)));
   }
 
   void StartPlayingFrom(int milliseconds) {
     SCOPED_TRACE(base::StringPrintf("StartPlayingFrom(%d)", milliseconds));
-    renderer_->StartPlayingFrom(
-        base::TimeDelta::FromMilliseconds(milliseconds));
+    const base::TimeDelta media_time =
+        base::TimeDelta::FromMilliseconds(milliseconds);
+    time_source_.SetMediaTime(media_time);
+    renderer_->StartPlayingFrom(media_time);
     message_loop_.RunUntilIdle();
   }
 
   void Flush() {
     SCOPED_TRACE("Flush()");
     WaitableMessageLoopEvent event;
     renderer_->Flush(event.GetClosure());
     event.RunAndWait();
   }
 
@@ skipping 115 matching lines @@
   void AdvanceWallclockTimeInMs(int time_ms) {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     base::AutoLock l(lock_);
     tick_clock_->Advance(base::TimeDelta::FromMilliseconds(time_ms));
   }
 
   void AdvanceTimeInMs(int time_ms) {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     base::AutoLock l(lock_);
     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();
   }
 
  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.
   class MockCB {
    public:
     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_;
 
   PipelineStatistics last_pipeline_statistics_;
 
+  WallClockTimeSource time_source_;
+
  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());
     decode_cb_ = decode_cb;
 
     // Wake up WaitForPendingRead() if needed.
     if (!wait_for_pending_decode_cb_.is_null())
       base::ResetAndReturn(&wait_for_pending_decode_cb_).Run();
 
@@ skipping 119 matching lines @@
   Destroy();
 }
 
 TEST_P(VideoRendererImplTest, DecodeError_Playing) {
   Initialize();
   QueueFrames("0 10 20 30");
   EXPECT_CALL(mock_cb_, FrameReceived(_)).Times(testing::AtLeast(1));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(0);
   renderer_->OnTimeStateChanged(true);
+  time_source_.StartTicking();
   AdvanceTimeInMs(10);
 
   QueueFrames("error");
   SatisfyPendingRead();
   WaitForError(PIPELINE_ERROR_DECODE);
   Destroy();
 }
 
 TEST_P(VideoRendererImplTest, DecodeError_DuringStartPlayingFrom) {
   Initialize();
@@ skipping 42 matching lines @@
   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();
 
   renderer_->OnTimeStateChanged(true);
+  time_source_.StartTicking();
+
   WaitableMessageLoopEvent event;
   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.
@@ skipping 29 matching lines @@
     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;
-    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(30)))
-        .Times(0);
-    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(60)))
-        .Times(0);
+
+    // 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();
+    if (GetParam())
+      EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(30))).Times(0);
+    else
+      EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(30))).Times(AnyNumber());
+
+    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.
@@ skipping 106 matching lines @@
     EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
     EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)))
         .WillOnce(RunClosure(event.GetClosure()));
     StartPlayingFrom(0);
     event.RunAndWait();
     Mock::VerifyAndClearExpectations(&mock_cb_);
     EXPECT_EQ(0u, last_pipeline_statistics_.video_frames_dropped);
   }
 
   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);
 
   AdvanceTimeInMs(30);
   WaitForEnded();
   Destroy();
 }
 
 INSTANTIATE_TEST_CASE_P(OldVideoRenderer,
                         VideoRendererImplTest,
                         testing::Values(false));
 INSTANTIATE_TEST_CASE_P(NewVideoRenderer,
                         VideoRendererImplTest,
                         testing::Values(true));
 
 }  // namespace media