Move VideoRenderer out of Filter heirarchy.

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.h"
 #include "base/stl_util.h"
 #include "base/threading/simple_thread.h"
 #include "media/base/clock.h"
-#include "media/base/filter_host.h"
-#include "media/base/filters.h"
 #include "media/base/media_log.h"
 #include "media/base/pipeline.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/size.h"
 
 using ::testing::_;
 using ::testing::DeleteArg;
 using ::testing::DoAll;
@@ skipping 149 matching lines @@
   }
 
   // Sets up expectations to allow the audio decoder to initialize.
   void InitializeAudioDecoder(const scoped_refptr<DemuxerStream>& stream) {
     EXPECT_CALL(*mocks_->audio_decoder(), Initialize(stream, _, _))
         .WillOnce(RunPipelineStatusCB1());
   }
 
   // Sets up expectations to allow the video renderer to initialize.
   void InitializeVideoRenderer() {
-    EXPECT_CALL(*mocks_->video_renderer(), SetHost(NotNull()));
     EXPECT_CALL(*mocks_->video_renderer(), Initialize(
-        scoped_refptr<VideoDecoder>(mocks_->video_decoder()), _, _, _))
+        scoped_refptr<VideoDecoder>(mocks_->video_decoder()),
+        _, _, _, _, _, _, _, _))
         .WillOnce(RunPipelineStatusCB1());
     EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(0.0f));
 
     // Startup sequence.
     EXPECT_CALL(*mocks_->video_renderer(),
                 Seek(mocks_->demuxer()->GetStartTime(), _))
         .WillOnce(RunPipelineStatusCB1());
     EXPECT_CALL(*mocks_->video_renderer(), Play(_))
         .WillOnce(RunClosure());
   }
@@ skipping 82 matching lines @@
     // We expect a successful seek callback.
     EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
   }
 
   void DoSeek(const base::TimeDelta& seek_time) {
     pipeline_->Seek(seek_time,
                     base::Bind(&CallbackHelper::OnSeek,
                                base::Unretained(&callbacks_)));
 
     // We expect the time to be updated only after the seek has completed.
-    EXPECT_NE(seek_time, pipeline_->GetCurrentTime());
+    EXPECT_NE(seek_time, pipeline_->GetMediaTime());
     message_loop_.RunAllPending();
-    EXPECT_EQ(seek_time, pipeline_->GetCurrentTime());
+    EXPECT_EQ(seek_time, pipeline_->GetMediaTime());
   }
 
   // Fixture members.
   StrictMock<CallbackHelper> callbacks_;
   MessageLoop message_loop_;
   scoped_refptr<Pipeline> pipeline_;
   scoped_ptr<media::MockFilterCollection> mocks_;
   scoped_refptr<StrictMock<MockDemuxerStream> > audio_stream_;
   scoped_refptr<StrictMock<MockDemuxerStream> > video_stream_;
   AudioRenderer::TimeCB audio_time_cb_;
@@ skipping 19 matching lines @@
   pipeline_->SetPlaybackRate(1.0f);
   EXPECT_EQ(1.0f, pipeline_->GetPlaybackRate());
 
   // Setting should still work.
   EXPECT_EQ(1.0f, pipeline_->GetVolume());
   pipeline_->SetVolume(-1.0f);
   EXPECT_EQ(1.0f, pipeline_->GetVolume());
   pipeline_->SetVolume(0.0f);
   EXPECT_EQ(0.0f, pipeline_->GetVolume());
 
-  EXPECT_TRUE(kZero == pipeline_->GetCurrentTime());
+  EXPECT_TRUE(kZero == pipeline_->GetMediaTime());
   EXPECT_EQ(0u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_TRUE(kZero == pipeline_->GetMediaDuration());
 
   EXPECT_EQ(0, pipeline_->GetTotalBytes());
 
   // Should always get set to zero.
   gfx::Size size(1, 1);
   pipeline_->GetNaturalVideoSize(&size);
   EXPECT_EQ(0, size.width());
   EXPECT_EQ(0, size.height());
@@ skipping 237 matching lines @@
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_CALL(*mocks_->demuxer(), OnAudioRendererDisabled());
   pipeline_->OnAudioDisabled();
 
   // Verify that ended event is fired when video ends.
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
-  FilterHost* host = pipeline_;
-  host->NotifyEnded();
+  pipeline_->OnRendererEnded();
 }
 
 TEST_F(PipelineTest, DisableAudioRendererDuringInit) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer(true);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   EXPECT_CALL(*mocks_->demuxer(),
               OnAudioRendererDisabled());
 
   InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   // Verify that ended event is fired when video ends.
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
-  FilterHost* host = pipeline_;
-  host->NotifyEnded();
+  pipeline_->OnRendererEnded();
 }
 
 TEST_F(PipelineTest, EndedCallback) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
   InitializePipeline(PIPELINE_OK);
 
-  // For convenience to simulate filters calling the methods.
-  FilterHost* host = pipeline_;
-
   // Due to short circuit evaluation we only need to test a subset of cases.
   InSequence s;
   EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
       .WillOnce(Return(false));
-  host->NotifyEnded();
+  pipeline_->OnRendererEnded();
 
   EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(false));
-  host->NotifyEnded();
+  pipeline_->OnRendererEnded();
 
   EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
-  host->NotifyEnded();
+  pipeline_->OnRendererEnded();
 }
 
 // Static function & time variable used to simulate changes in wallclock time.
 static int64 g_static_clock_time;
 static base::Time StaticClockFunction() {
   return base::Time::FromInternalValue(g_static_clock_time);
 }
 
 TEST_F(PipelineTest, AudioStreamShorterThanVideo) {
   base::TimeDelta duration = base::TimeDelta::FromSeconds(10);
 
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   // Replace the clock so we can simulate wallclock time advancing w/o using
   // Sleep().
   pipeline_->SetClockForTesting(new Clock(&StaticClockFunction));
 
   InitializeDemuxer(&streams, duration);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
   InitializePipeline(PIPELINE_OK);
 
-  // For convenience to simulate filters calling the methods.
-  FilterHost* host = pipeline_;
-
-  EXPECT_EQ(0, host->GetTime().ToInternalValue());
+  EXPECT_EQ(0, pipeline_->GetMediaTime().ToInternalValue());
 
   float playback_rate = 1.0f;
   EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(playback_rate));
   pipeline_->SetPlaybackRate(playback_rate);
   message_loop_.RunAllPending();
 
   InSequence s;
 
   // Verify that the clock doesn't advance since it hasn't been started by
   // a time update from the audio stream.
-  int64 start_time = host->GetTime().ToInternalValue();
+  int64 start_time = pipeline_->GetMediaTime().ToInternalValue();
   g_static_clock_time +=
       base::TimeDelta::FromMilliseconds(100).ToInternalValue();
-  EXPECT_EQ(host->GetTime().ToInternalValue(), start_time);
+  EXPECT_EQ(pipeline_->GetMediaTime().ToInternalValue(), start_time);
 
   // Signal end of audio stream.
   EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(false));
-  host->NotifyEnded();
+  pipeline_->OnRendererEnded();
   message_loop_.RunAllPending();
 
   // Verify that the clock advances.
-  start_time = host->GetTime().ToInternalValue();
+  start_time = pipeline_->GetMediaTime().ToInternalValue();
   g_static_clock_time +=
       base::TimeDelta::FromMilliseconds(100).ToInternalValue();
-  EXPECT_GT(host->GetTime().ToInternalValue(), start_time);
+  EXPECT_GT(pipeline_->GetMediaTime().ToInternalValue(), start_time);
 
   // Signal end of video stream and make sure OnEnded() callback occurs.
   EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
-  host->NotifyEnded();
+  pipeline_->OnRendererEnded();
 }
 
 TEST_F(PipelineTest, ErrorDuringSeek) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(10));
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
@@ skipping 90 matching lines @@
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
   InitializeDemuxer(&streams, kDuration);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
-  EXPECT_EQ(base::TimeDelta(), pipeline_->GetCurrentTime());
+  EXPECT_EQ(base::TimeDelta(), pipeline_->GetMediaTime());
 }
 
 TEST_F(PipelineTest, StartTimeIsNonZero) {
   const base::TimeDelta kStartTime = base::TimeDelta::FromSeconds(4);
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
 
   EXPECT_CALL(*mocks_->demuxer(), GetStartTime())
       .WillRepeatedly(Return(kStartTime));
 
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams, kDuration);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
-  EXPECT_EQ(kStartTime, pipeline_->GetCurrentTime());
+  EXPECT_EQ(kStartTime, pipeline_->GetMediaTime());
 }
 
 static void RunTimeCB(const AudioRenderer::TimeCB& time_cb,
                        int time_in_ms,
                        int max_time_in_ms) {
   time_cb.Run(base::TimeDelta::FromMilliseconds(time_in_ms),
               base::TimeDelta::FromMilliseconds(max_time_in_ms));
 }
 
 TEST_F(PipelineTest, AudioTimeUpdateDuringSeek) {
@@ skipping 32 matching lines @@
   EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
       .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Seek(seek_time, _))
       .WillOnce(RunPipelineStatusCB1());
   EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
       .WillOnce(RunClosure());
 
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
   DoSeek(seek_time);
 
-  EXPECT_EQ(pipeline_->GetCurrentTime(), seek_time);
+  EXPECT_EQ(pipeline_->GetMediaTime(), seek_time);
 
   // Now that the seek is complete, verify that time updates advance the current
   // time.
   base::TimeDelta new_time = seek_time + base::TimeDelta::FromMilliseconds(100);
   audio_time_cb_.Run(new_time, new_time);
 
-  EXPECT_EQ(pipeline_->GetCurrentTime(), new_time);
+  EXPECT_EQ(pipeline_->GetMediaTime(), new_time);
 }
 
 class FlexibleCallbackRunner : public base::DelegateSimpleThread::Delegate {
  public:
   FlexibleCallbackRunner(base::TimeDelta delay, PipelineStatus status,
                          const PipelineStatusCB& status_cb)
       : delay_(delay),
         status_(status),
         status_cb_(status_cb) {
     if (delay_ < base::TimeDelta()) {
@@ skipping 36 matching lines @@
   TestPipelineStatusNotification(base::TimeDelta::FromMilliseconds(0));
 }
 
 // Test that different-thread, some-delay callback (the expected common case)
 // works correctly.
 TEST(PipelineStatusNotificationTest, DelayedCallback) {
   TestPipelineStatusNotification(base::TimeDelta::FromMilliseconds(20));
 }
 
 }  // namespace media