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 382 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_->GetCurrentTime().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_->GetCurrentTime().ToInternalValue();
   g_static_clock_time +=
       base::TimeDelta::FromMilliseconds(100).ToInternalValue();
-  EXPECT_EQ(host->GetTime().ToInternalValue(), start_time);
+  EXPECT_EQ(pipeline_->GetCurrentTime().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_->GetCurrentTime().ToInternalValue();
   g_static_clock_time +=
       base::TimeDelta::FromMilliseconds(100).ToInternalValue();
-  EXPECT_GT(host->GetTime().ToInternalValue(), start_time);
+  EXPECT_GT(pipeline_->GetCurrentTime().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 230 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