Move AudioRenderer 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"
@@ skipping 21 matching lines @@
 using ::testing::StrictMock;
 using ::testing::WithArg;
 
 namespace media {
 
 // Demuxer properties.
 static const int kTotalBytes = 1024;
 static const int kBufferedBytes = 1024;
 static const int kBitrate = 1234;
 
-ACTION_P(InitializeDemuxerWithError, error) {
-  arg1.Run(error);
-}
-
 ACTION_P(SetDemuxerProperties, duration) {
   arg0->SetTotalBytes(kTotalBytes);
   arg0->SetDuration(duration);
 }
 
-ACTION_P(DisableAudioRenderer, pipeline) {
-  FilterHost* host = pipeline;
-  host->DisableAudioRenderer();
+ACTION(RunPipelineStatusCB1) {
+  arg1.Run(PIPELINE_OK);
+}
+
+ACTION_P(RunPipelineStatusCB1WithStatus, status) {
+  arg1.Run(status);
 }
 
 // Used for setting expectations on pipeline callbacks.  Using a StrictMock
 // also lets us test for missing callbacks.
 class CallbackHelper {
  public:
   CallbackHelper() {}
   virtual ~CallbackHelper() {}
 
   MOCK_METHOD1(OnStart, void(PipelineStatus));
@@ skipping 29 matching lines @@
   }
 
   virtual ~PipelineTest() {
     if (!pipeline_->IsRunning()) {
       return;
     }
 
     // Shutdown sequence.
     if (pipeline_->IsInitialized()) {
       EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-          .WillOnce(Invoke(&RunClosure));
+          .WillOnce(RunClosure());
 
       if (audio_stream_) {
         EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
-            .WillOnce(Invoke(&RunClosure));
+            .WillOnce(RunClosure());
         EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
-            .WillOnce(Invoke(&RunClosure));
+            .WillOnce(RunClosure());
         EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
-            .WillOnce(Invoke(&RunClosure));
+            .WillOnce(RunClosure());
       }
 
       if (video_stream_) {
         EXPECT_CALL(*mocks_->video_renderer(), Pause(_))
-            .WillOnce(Invoke(&RunClosure));
+            .WillOnce(RunClosure());
         EXPECT_CALL(*mocks_->video_renderer(), Flush(_))
-            .WillOnce(Invoke(&RunClosure));
+            .WillOnce(RunClosure());
         EXPECT_CALL(*mocks_->video_renderer(), Stop(_))
-            .WillOnce(Invoke(&RunClosure));
+            .WillOnce(RunClosure());
       }
     }
 
     // Expect a stop callback if we were started.
     EXPECT_CALL(callbacks_, OnStop());
     pipeline_->Stop(base::Bind(&CallbackHelper::OnStop,
                                base::Unretained(&callbacks_)));
     message_loop_.RunAllPending();
 
     pipeline_ = NULL;
     mocks_.reset();
   }
 
  protected:
   // Sets up expectations to allow the demuxer to initialize.
   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
   void InitializeDemuxer(MockDemuxerStreamVector* streams,
                          const base::TimeDelta& duration) {
     EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
         .WillOnce(DoAll(SetDemuxerProperties(duration),
-                        Invoke(&RunPipelineStatusCB2)));
+                        RunPipelineStatusCB1()));
     EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
 
     // Demuxer properties.
     EXPECT_CALL(*mocks_->demuxer(), GetBitrate())
         .WillRepeatedly(Return(kBitrate));
 
     // Configure the demuxer to return the streams.
     for (size_t i = 0; i < streams->size(); ++i) {
       scoped_refptr<DemuxerStream> stream((*streams)[i]);
       EXPECT_CALL(*mocks_->demuxer(), GetStream(stream->type()))
@@ skipping 11 matching lines @@
         new StrictMock<MockDemuxerStream>();
     EXPECT_CALL(*stream, type())
         .WillRepeatedly(Return(type));
     return stream;
   }
 
   // Sets up expectations to allow the video decoder to initialize.
   void InitializeVideoDecoder(const scoped_refptr<DemuxerStream>& stream) {
     EXPECT_CALL(*mocks_->video_decoder(),
                 Initialize(stream, _, _))
-        .WillOnce(Invoke(&RunPipelineStatusCB3));
+        .WillOnce(RunPipelineStatusCB1());
   }
 
   // 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(Invoke(&RunPipelineStatusCB3));
+        .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()), _, _, _))
-        .WillOnce(Invoke(&RunPipelineStatusCB4));
+        .WillOnce(RunPipelineStatusCB1());
     EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(0.0f));
 
     // Startup sequence.
     EXPECT_CALL(*mocks_->video_renderer(),
                 Seek(mocks_->demuxer()->GetStartTime(), _))
-        .WillOnce(Invoke(&RunPipelineStatusCB2));
+        .WillOnce(RunPipelineStatusCB1());
     EXPECT_CALL(*mocks_->video_renderer(), Play(_))
-        .WillOnce(Invoke(&RunClosure));
+        .WillOnce(RunClosure());
   }
 
   // Sets up expectations to allow the audio renderer to initialize.
   void InitializeAudioRenderer(bool disable_after_init_cb = false) {
-    EXPECT_CALL(*mocks_->audio_renderer(), SetHost(NotNull()));
     if (disable_after_init_cb) {
       EXPECT_CALL(*mocks_->audio_renderer(), Initialize(
-          scoped_refptr<AudioDecoder>(mocks_->audio_decoder()), _, _, _))
-          .WillOnce(DoAll(Invoke(&RunPipelineStatusCB4),
-                          DisableAudioRenderer(pipeline_)));
+          scoped_refptr<AudioDecoder>(mocks_->audio_decoder()), _, _, _, _, _))
+          .WillOnce(DoAll(RunPipelineStatusCB1(),
+                          WithArg<5>(RunClosure()))); // |disabled_cb|.

[acolwell GONE FROM CHROMIUM, 2012/07/19 00:58:18]

nit: 2 spaces before comment

[scherkus (not reviewing), 2012/07/19 21:29:02]

Done.

     } else {
       EXPECT_CALL(*mocks_->audio_renderer(), Initialize(
-          scoped_refptr<AudioDecoder>(mocks_->audio_decoder()), _, _, _))
+          scoped_refptr<AudioDecoder>(mocks_->audio_decoder()), _, _, _, _, _))
           .WillOnce(DoAll(SaveArg<3>(&audio_time_cb_),
-                          Invoke(&RunPipelineStatusCB4)));
+                          RunPipelineStatusCB1()));
     }
     EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(1.0f));
 
     // Startup sequence.
     EXPECT_CALL(*mocks_->audio_renderer(), Seek(base::TimeDelta(), _))
-        .WillOnce(Invoke(&RunPipelineStatusCB2));
+        .WillOnce(RunPipelineStatusCB1());
     EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
-        .WillOnce(Invoke(&RunClosure));
+        .WillOnce(RunClosure());
   }
 
   // Sets up expectations on the callback and initializes the pipeline.  Called
   // after tests have set expectations any filters they wish to use.
   void InitializePipeline(PipelineStatus start_status) {
     EXPECT_CALL(callbacks_, OnStart(start_status));
 
     pipeline_->Start(
         mocks_->Create().Pass(),
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
@@ skipping 14 matching lines @@
     return audio_stream_;
   }
 
   MockDemuxerStream* video_stream() {
     return video_stream_;
   }
 
   void ExpectSeek(const base::TimeDelta& seek_time) {
     // Every filter should receive a call to Seek().
     EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
-        .WillOnce(Invoke(&RunPipelineStatusCB2));
+        .WillOnce(RunPipelineStatusCB1());
 
     if (audio_stream_) {
       EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
-          .WillOnce(Invoke(&RunClosure));
+          .WillOnce(RunClosure());
       EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
-          .WillOnce(Invoke(&RunClosure));
+          .WillOnce(RunClosure());
       EXPECT_CALL(*mocks_->audio_renderer(), Seek(seek_time, _))
-          .WillOnce(Invoke(&RunPipelineStatusCB2));
+          .WillOnce(RunPipelineStatusCB1());
       EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
-          .WillOnce(Invoke(&RunClosure));
+          .WillOnce(RunClosure());
     }
 
     if (video_stream_) {
       EXPECT_CALL(*mocks_->video_renderer(), Pause(_))
-          .WillOnce(Invoke(&RunClosure));
+          .WillOnce(RunClosure());
       EXPECT_CALL(*mocks_->video_renderer(), Flush(_))
-          .WillOnce(Invoke(&RunClosure));
+          .WillOnce(RunClosure());
       EXPECT_CALL(*mocks_->video_renderer(), Seek(seek_time, _))
-          .WillOnce(Invoke(&RunPipelineStatusCB2));
+          .WillOnce(RunPipelineStatusCB1());
       EXPECT_CALL(*mocks_->video_renderer(), Play(_))
-          .WillOnce(Invoke(&RunClosure));
+          .WillOnce(RunClosure());
     }
 
     // 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_)));
@@ skipping 51 matching lines @@
   gfx::Size size(1, 1);
   pipeline_->GetNaturalVideoSize(&size);
   EXPECT_EQ(0, size.width());
   EXPECT_EQ(0, size.height());
 }
 
 TEST_F(PipelineTest, NeverInitializes) {
   // Don't execute the callback passed into Initialize().
   EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _));
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(Invoke(&RunClosure));
+      .WillOnce(RunClosure());
 
   // This test hangs during initialization by never calling
   // InitializationComplete().  StrictMock<> will ensure that the callback is
   // never executed.
   pipeline_->Start(
         mocks_->Create().Pass(),
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
   message_loop_.RunAllPending();
@@ skipping 17 matching lines @@
       collection.Pass(),
       base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
       base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
       base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
   message_loop_.RunAllPending();
   EXPECT_FALSE(pipeline_->IsInitialized());
 }
 
 TEST_F(PipelineTest, URLNotFound) {
   EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
-      .WillOnce(InitializeDemuxerWithError(PIPELINE_ERROR_URL_NOT_FOUND));
+      .WillOnce(RunPipelineStatusCB1WithStatus(PIPELINE_ERROR_URL_NOT_FOUND));
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(Invoke(&RunClosure));
+      .WillOnce(RunClosure());
 
   InitializePipeline(PIPELINE_ERROR_URL_NOT_FOUND);
   EXPECT_FALSE(pipeline_->IsInitialized());
 }
 
 TEST_F(PipelineTest, NoStreams) {
   EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
-      .WillOnce(Invoke(&RunPipelineStatusCB2));
+      .WillOnce(RunPipelineStatusCB1());
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(Invoke(&RunClosure));
+      .WillOnce(RunClosure());
 
   InitializePipeline(PIPELINE_ERROR_COULD_NOT_RENDER);
   EXPECT_FALSE(pipeline_->IsInitialized());
 }
 
 TEST_F(PipelineTest, AudioStream) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
@@ skipping 163 matching lines @@
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
-  EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(1.0f))
-      .WillOnce(DisableAudioRenderer(pipeline_));
-  EXPECT_CALL(*mocks_->demuxer(),
-              OnAudioRendererDisabled());
-
-  mocks_->audio_renderer()->SetPlaybackRate(1.0f);
+  EXPECT_CALL(*mocks_->demuxer(), OnAudioRendererDisabled());
+  pipeline_->OnAudioDisabled();
+  message_loop_.RunAllPending();

[acolwell GONE FROM CHROMIUM, 2012/07/19 00:58:18]

Why do you need to run the message_loop_ now?

[scherkus (not reviewing), 2012/07/19 21:29:02]

Turns out I don't need to!

I thought we might have to due to trampolining but the trampoline in this is
case is conditional

 
   // 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();
 }
 
 TEST_F(PipelineTest, DisableAudioRendererDuringInit) {
@@ skipping 125 matching lines @@
 
   // 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();
 }
 
-void SendReadErrorToCB(::testing::Unused, const PipelineStatusCB& cb) {
-  cb.Run(PIPELINE_ERROR_READ);
-}
-
 TEST_F(PipelineTest, ErrorDuringSeek) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(10));
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializePipeline(PIPELINE_OK);
 
   float playback_rate = 1.0f;
   EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(playback_rate));
   pipeline_->SetPlaybackRate(playback_rate);
   message_loop_.RunAllPending();
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   // Seek() isn't called as the demuxer errors out first.
   EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
-      .WillOnce(Invoke(&RunClosure));
+      .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
-      .WillOnce(Invoke(&RunClosure));
+      .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
-      .WillOnce(Invoke(&RunClosure));
+      .WillOnce(RunClosure());
 
   EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
-      .WillOnce(Invoke(&SendReadErrorToCB));
+      .WillOnce(RunPipelineStatusCB1WithStatus(PIPELINE_ERROR_READ));
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(Invoke(&RunClosure));
+      .WillOnce(RunClosure());
 
   pipeline_->Seek(seek_time, base::Bind(&CallbackHelper::OnSeek,
                                         base::Unretained(&callbacks_)));
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
   message_loop_.RunAllPending();
 }
 
 // Invoked function OnError. This asserts that the pipeline does not enqueue
 // non-teardown related tasks while tearing down.
 static void TestNoCallsAfterError(
@@ skipping 26 matching lines @@
   // Trigger additional requests on the pipeline during tear down from error.
   base::Callback<void(PipelineStatus)> cb = base::Bind(
       &TestNoCallsAfterError, pipeline_, &message_loop_);
   ON_CALL(callbacks_, OnError(_))
       .WillByDefault(Invoke(&cb, &base::Callback<void(PipelineStatus)>::Run));
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   // Seek() isn't called as the demuxer errors out first.
   EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
-      .WillOnce(Invoke(&RunClosure));
+      .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
-      .WillOnce(Invoke(&RunClosure));
+      .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
-      .WillOnce(Invoke(&RunClosure));
+      .WillOnce(RunClosure());
 
   EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
-      .WillOnce(Invoke(&SendReadErrorToCB));
+      .WillOnce(RunPipelineStatusCB1WithStatus(PIPELINE_ERROR_READ));
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(Invoke(&RunClosure));
+      .WillOnce(RunClosure());
 
   pipeline_->Seek(seek_time, base::Bind(&CallbackHelper::OnSeek,
                                         base::Unretained(&callbacks_)));
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
   message_loop_.RunAllPending();
 }
 
 TEST_F(PipelineTest, StartTimeIsZero) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
@@ skipping 64 matching lines @@
                      base::TimeDelta::FromMilliseconds(500));
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   // Arrange to trigger a time update while the demuxer is in the middle of
   // seeking. This update should be ignored by the pipeline and the clock should
   // not get updated.
   base::Closure closure = base::Bind(&RunTimeCB, audio_time_cb_, 300, 700);
   EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&closure, &base::Closure::Run),
-                      Invoke(&RunPipelineStatusCB2)));
+                      RunPipelineStatusCB1()));
 
   EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
-      .WillOnce(Invoke(&RunClosure));
+      .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
-      .WillOnce(Invoke(&RunClosure));
+      .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Seek(seek_time, _))
-      .WillOnce(Invoke(&RunPipelineStatusCB2));
+      .WillOnce(RunPipelineStatusCB1());
   EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
-      .WillOnce(Invoke(&RunClosure));
+      .WillOnce(RunClosure());
 
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
   DoSeek(seek_time);
 
   EXPECT_EQ(pipeline_->GetCurrentTime(), 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);
@@ skipping 48 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