Change the TimeSource interface to return wallclock time for video.

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/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::_;
@@ skipping 11 matching lines @@
 }
 
 MATCHER_P(HasTimestamp, ms, "") {
   *result_listener << "has timestamp " << arg->timestamp().InMilliseconds();
   return arg->timestamp().InMilliseconds() == ms;
 }
 
 class VideoRendererImplTest : public ::testing::Test {
  public:
   VideoRendererImplTest()
-      : decoder_(new MockVideoDecoder()),
+      : 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(),
                                           decoders.Pass(), true,
                                           new MediaLog()));
+    renderer_->SetTickClockForTesting(scoped_ptr<base::TickClock>(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))));
   }
 
   virtual ~VideoRendererImplTest() {}
@@ skipping 30 matching lines @@
         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_)),
         base::Bind(&StrictMock<MockCB>::Display, base::Unretained(&mock_cb_)),
         ended_event_.GetClosure(), error_event_.GetPipelineStatusCB(),
-        base::Bind(&VideoRendererImplTest::GetTime, base::Unretained(this)),
+        base::Bind(&VideoRendererImplTest::GetWallclockTimeForMediaTime,
+                   base::Unretained(this)),
         base::Bind(&VideoRendererImplTest::OnWaitingForDecryptionKey,
                    base::Unretained(this)));
   }
 
   void StartPlayingFrom(int milliseconds) {
     SCOPED_TRACE(base::StringPrintf("StartPlayingFrom(%d)", milliseconds));
     renderer_->StartPlayingFrom(
         base::TimeDelta::FromMilliseconds(milliseconds));
     message_loop_.RunUntilIdle();
   }
@@ skipping 113 matching lines @@
         FROM_HERE,
         base::Bind(base::ResetAndReturn(&decode_cb_), VideoDecoder::kOk));
 
     WaitForPendingRead();
 
     message_loop_.PostTask(
         FROM_HERE,
         base::Bind(base::ResetAndReturn(&decode_cb_), VideoDecoder::kOk));
   }
 
+  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);
   }
 
  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(Display, void(const scoped_refptr<VideoFrame>&));
     MOCK_METHOD1(BufferingStateChange, void(BufferingState));
   };
   StrictMock<MockCB> mock_cb_;
 
  private:
-  base::TimeDelta GetTime() {
+  base::TimeTicks GetWallclockTimeForMediaTime(base::TimeDelta time) {
     base::AutoLock l(lock_);
-    return time_;
+    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())
@@ skipping 199 matching lines @@
   Initialize();
   QueueFrames("0 10 20 30");
   EXPECT_CALL(mock_cb_, Display(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(0);
 
   // Advance time slightly. Frames should be dropped and we should NOT signal
   // having nothing.
   AdvanceTimeInMs(100);
 
-  // Advance time more. Now we should signal having nothing.
+  // Now that all frames are dropped, we should signal having nothing.
   {
     SCOPED_TRACE("Waiting for BUFFERING_HAVE_NOTHING");
     WaitableMessageLoopEvent event;
     EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_NOTHING))
         .WillOnce(RunClosure(event.GetClosure()));
-    AdvanceTimeInMs(3000);  // Must match kTimeToDeclareHaveNothing.
     event.RunAndWait();
   }
 
   // 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();
 }
 
 }  // namespace media