Drop time from media::{Audio,Video}Renderer::StartPlayingFrom().

media/base/pipeline_unittest.cc

 // Copyright (c) 2012 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 <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 69 matching lines @@
 // is executed on |message_loop_| and the mock filters instantly call
 // InitializationComplete(), which keeps the pipeline humming along.  If
 // either filters don't call InitializationComplete() immediately or filter
 // initialization is moved to a separate thread this test will become flaky.
 class PipelineTest : public ::testing::Test {
  public:
   PipelineTest()
       : pipeline_(new Pipeline(message_loop_.message_loop_proxy(),
                                new MediaLog())),
         filter_collection_(new FilterCollection()),
-        demuxer_(new MockDemuxer()) {
+        demuxer_(new StrictMock<MockDemuxer>()) {
     filter_collection_->SetDemuxer(demuxer_.get());
 
-    video_renderer_ = new MockVideoRenderer();
+    video_renderer_ = new StrictMock<MockVideoRenderer>();
     scoped_ptr<VideoRenderer> video_renderer(video_renderer_);
     filter_collection_->SetVideoRenderer(video_renderer.Pass());
 
-    audio_renderer_ = new MockAudioRenderer();
+    audio_renderer_ = new StrictMock<MockAudioRenderer>();
     scoped_ptr<AudioRenderer> audio_renderer(audio_renderer_);
     filter_collection_->SetAudioRenderer(audio_renderer.Pass());
 
     text_renderer_ = new TextRenderer(
                          message_loop_.message_loop_proxy(),
                          base::Bind(&PipelineTest::OnAddTextTrack,
                                     base::Unretained(this)));
     scoped_ptr<TextRenderer> text_renderer(text_renderer_);
     filter_collection_->SetTextRenderer(text_renderer.Pass());
 
@@ skipping 88 matching lines @@
   // after tests have set expectations any filters they wish to use.
   void StartPipeline(PipelineStatus start_status) {
     EXPECT_CALL(callbacks_, OnStart(start_status));
 
     if (start_status == PIPELINE_OK) {
       EXPECT_CALL(callbacks_, OnMetadata(_)).WillOnce(SaveArg<0>(&metadata_));
 
       if (audio_stream_) {
         EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f));
         EXPECT_CALL(*audio_renderer_, SetVolume(1.0f));
-        EXPECT_CALL(*audio_renderer_, StartPlayingFrom(base::TimeDelta()))
+        EXPECT_CALL(*audio_renderer_, SetMediaTime(base::TimeDelta()));
+        EXPECT_CALL(*audio_renderer_, StartPlaying())
             .WillOnce(SetBufferingState(&audio_buffering_state_cb_,
                                         BUFFERING_HAVE_ENOUGH));
         EXPECT_CALL(*audio_renderer_, StartRendering());
       }
 
       if (video_stream_) {
-        EXPECT_CALL(*video_renderer_, StartPlayingFrom(base::TimeDelta()))
+        EXPECT_CALL(*video_renderer_, StartPlaying())
             .WillOnce(SetBufferingState(&video_buffering_state_cb_,
                                         BUFFERING_HAVE_ENOUGH));
       }
 
       EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
     }
 
     pipeline_->Start(
         filter_collection_.Pass(),
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
@@ skipping 39 matching lines @@
     EXPECT_CALL(*demuxer_, Seek(seek_time, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     if (audio_stream_) {
       if (!underflowed)
         EXPECT_CALL(*audio_renderer_, StopRendering());
       EXPECT_CALL(*audio_renderer_, Flush(_))
           .WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_,
                                             BUFFERING_HAVE_NOTHING),
                           RunClosure<0>()));
-      EXPECT_CALL(*audio_renderer_, StartPlayingFrom(seek_time))
+      EXPECT_CALL(*audio_renderer_, SetMediaTime(seek_time));
+      EXPECT_CALL(*audio_renderer_, StartPlaying())
           .WillOnce(SetBufferingState(&audio_buffering_state_cb_,
                                       BUFFERING_HAVE_ENOUGH));
       EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_));
       EXPECT_CALL(*audio_renderer_, SetVolume(_));
       EXPECT_CALL(*audio_renderer_, StartRendering());
     }
 
     if (video_stream_) {
       EXPECT_CALL(*video_renderer_, Flush(_))
           .WillOnce(DoAll(SetBufferingState(&video_buffering_state_cb_,
                                             BUFFERING_HAVE_NOTHING),
                           RunClosure<0>()));
-      EXPECT_CALL(*video_renderer_, StartPlayingFrom(seek_time))
+      EXPECT_CALL(*video_renderer_, StartPlaying())
           .WillOnce(SetBufferingState(&video_buffering_state_cb_,
                                       BUFFERING_HAVE_ENOUGH));
     }
 
     // We expect a successful seek callback followed by a buffering update.
     EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
     EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   }
 
   void DoSeek(const base::TimeDelta& seek_time) {
@@ skipping 27 matching lines @@
     done_cb.Run(text_track.Pass());
   }
 
   // Fixture members.
   StrictMock<CallbackHelper> callbacks_;
   base::SimpleTestTickClock test_tick_clock_;
   base::MessageLoop message_loop_;
   scoped_ptr<Pipeline> pipeline_;
 
   scoped_ptr<FilterCollection> filter_collection_;
-  scoped_ptr<MockDemuxer> demuxer_;
-  MockVideoRenderer* video_renderer_;
-  MockAudioRenderer* audio_renderer_;
+  scoped_ptr<StrictMock<MockDemuxer>> demuxer_;
+  StrictMock<MockVideoRenderer>* video_renderer_;
+  StrictMock<MockAudioRenderer>* audio_renderer_;
   StrictMock<CallbackHelper> text_renderer_callbacks_;
   TextRenderer* text_renderer_;
   scoped_ptr<StrictMock<MockDemuxerStream> > audio_stream_;
   scoped_ptr<StrictMock<MockDemuxerStream> > video_stream_;
   scoped_ptr<FakeTextTrackStream> text_stream_;
   AudioRenderer::TimeCB audio_time_cb_;
   BufferingStateCB audio_buffering_state_cb_;
   BufferingStateCB video_buffering_state_cb_;
   base::Closure audio_ended_cb_;
   base::Closure video_ended_cb_;
@@ skipping 439 matching lines @@
   base::Closure closure = base::Bind(&RunTimeCB, audio_time_cb_, 300, 700);
   EXPECT_CALL(*demuxer_, Seek(seek_time, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&closure, &base::Closure::Run),
                       RunCallback<1>(PIPELINE_OK)));
 
   EXPECT_CALL(*audio_renderer_, StopRendering());
   EXPECT_CALL(*audio_renderer_, Flush(_))
       .WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_,
                                         BUFFERING_HAVE_NOTHING),
                       RunClosure<0>()));
-  EXPECT_CALL(*audio_renderer_, StartPlayingFrom(seek_time))
+  EXPECT_CALL(*audio_renderer_, SetMediaTime(seek_time));
+  EXPECT_CALL(*audio_renderer_, StartPlaying())
       .WillOnce(SetBufferingState(&audio_buffering_state_cb_,
                                   BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_));
   EXPECT_CALL(*audio_renderer_, SetVolume(_));
   EXPECT_CALL(*audio_renderer_, StartRendering());
 
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
   EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   DoSeek(seek_time);
 
@@ skipping 179 matching lines @@
       return status;
     }
 
     EXPECT_CALL(*video_renderer_, Initialize(_, _, _, _, _, _, _, _, _, _))
         .WillOnce(DoAll(SaveArg<5>(&video_buffering_state_cb_),
                         RunCallback<2>(PIPELINE_OK)));
 
     EXPECT_CALL(callbacks_, OnMetadata(_));
 
     // If we get here it's a successful initialization.
-    EXPECT_CALL(*audio_renderer_, StartPlayingFrom(base::TimeDelta()))
+    EXPECT_CALL(*audio_renderer_, SetMediaTime(base::TimeDelta()));
+    EXPECT_CALL(*audio_renderer_, StartPlaying())
         .WillOnce(SetBufferingState(&audio_buffering_state_cb_,
                                     BUFFERING_HAVE_ENOUGH));
-    EXPECT_CALL(*video_renderer_, StartPlayingFrom(base::TimeDelta()))
+    EXPECT_CALL(*video_renderer_, StartPlaying())
         .WillOnce(SetBufferingState(&video_buffering_state_cb_,
                                     BUFFERING_HAVE_ENOUGH));
 
     EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f));
     EXPECT_CALL(*audio_renderer_, SetVolume(1.0f));
     EXPECT_CALL(*audio_renderer_, StartRendering());
 
     if (status == PIPELINE_OK)
       EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
 
@@ skipping 120 matching lines @@
 INSTANTIATE_TEARDOWN_TEST(Error, InitDemuxer);
 INSTANTIATE_TEARDOWN_TEST(Error, InitAudioRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, InitVideoRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, Flushing);
 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 
 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Playing);
 
 }  // namespace media