Remove DemuxerFactory and URL parameter from Pipeline.

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 <string>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/threading/simple_thread.h"
@@ skipping 37 matching lines @@
   MOCK_METHOD1(OnStart, void(PipelineStatus));
   MOCK_METHOD1(OnSeek, void(PipelineStatus));
   MOCK_METHOD1(OnStop, void(PipelineStatus));
   MOCK_METHOD1(OnEnded, void(PipelineStatus));
   MOCK_METHOD1(OnError, void(PipelineStatus));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
 };
 
-// Run |cb| w/ OK status.
-static void RunPipelineStatusOKCB(const PipelineStatusCB& cb) {
-  cb.Run(PIPELINE_OK);
-}
-
 // TODO(scherkus): even though some filters are initialized on separate
 // threads these test aren't flaky... why?  It's because filters' Initialize()
 // 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_, new MediaLog())) {
@@ skipping 13 matching lines @@
     if (!pipeline_->IsRunning()) {
       return;
     }
 
     // Expect a stop callback if we were started.
     EXPECT_CALL(callbacks_, OnStop(PIPELINE_OK));
     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(Invoke(&RunPipelineStatusCB));
     mocks_->demuxer()->SetTotalAndBufferedBytesAndDuration(
         kTotalBytes, kBufferedBytes, duration);
     EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->demuxer(), Seek(mocks_->demuxer()->GetStartTime(), _))
-        .WillOnce(Invoke(&RunPipelineStatusCB));
+        .WillOnce(Invoke(&RunPipelineStatusCB2));
     EXPECT_CALL(*mocks_->demuxer(), Stop(_))
         .WillOnce(Invoke(&RunStopFilterCallback));
 
     // 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()))
           .WillRepeatedly(Return(stream));
     }
   }
 
   StrictMock<MockDemuxerStream>* CreateStream(DemuxerStream::Type type) {
     StrictMock<MockDemuxerStream>* stream =
         new StrictMock<MockDemuxerStream>();
     EXPECT_CALL(*stream, type())
         .WillRepeatedly(Return(type));
     return stream;
   }
 
   // Sets up expectations to allow the video decoder to initialize.
   void InitializeVideoDecoder(MockDemuxerStream* stream) {
     EXPECT_CALL(*mocks_->video_decoder(),
                 Initialize(stream, _, _))
-        .WillOnce(WithArg<1>(Invoke(&RunPipelineStatusOKCB)));
+        .WillOnce(Invoke(&RunPipelineStatusCB3));
   }
 
   // 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));
   }
 
   // Sets up expectations to allow the video renderer to initialize.
   void InitializeVideoRenderer() {
     EXPECT_CALL(*mocks_->video_renderer(), Initialize(
         scoped_refptr<VideoDecoder>(mocks_->video_decoder()), _, _, _))
         .WillOnce(Invoke(&RunPipelineStatusCB4));
     EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->video_renderer(),
                 Seek(mocks_->demuxer()->GetStartTime(), _))
-        .WillOnce(Invoke(&RunPipelineStatusCB));
+        .WillOnce(Invoke(&RunPipelineStatusCB2));
     EXPECT_CALL(*mocks_->video_renderer(), Stop(_))
         .WillOnce(Invoke(&RunStopFilterCallback));
   }
 
   // Sets up expectations to allow the audio renderer to initialize.
   void InitializeAudioRenderer(bool disable_after_init_cb = false) {
     if (disable_after_init_cb) {
       EXPECT_CALL(*mocks_->audio_renderer(), Initialize(
           scoped_refptr<AudioDecoder>(mocks_->audio_decoder()), _, _, _))
           .WillOnce(DoAll(Invoke(&RunPipelineStatusCB4),
                           DisableAudioRenderer(mocks_->audio_renderer())));
     } else {
       EXPECT_CALL(*mocks_->audio_renderer(), Initialize(
           scoped_refptr<AudioDecoder>(mocks_->audio_decoder()), _, _, _))
           .WillOnce(Invoke(&RunPipelineStatusCB4));
     }
     EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(1.0f));
     EXPECT_CALL(*mocks_->audio_renderer(), Seek(base::TimeDelta(), _))
-        .WillOnce(Invoke(&RunPipelineStatusCB));
+        .WillOnce(Invoke(&RunPipelineStatusCB2));
     EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
         .WillOnce(Invoke(&RunStopFilterCallback));
   }
 
   // Sets up expectations on the callback and initializes the pipeline.  Called
   // after tests have set expectations any filters they wish to use.
-  void InitializePipeline() {
-    InitializePipeline(PIPELINE_OK);
-  }
-  // Most tests can expect the |filter_collection|'s |build_status| to get
-  // reflected in |Start()|'s argument.
   void InitializePipeline(PipelineStatus start_status) {
-    InitializePipeline(start_status, start_status);
-  }
-  // But some tests require different statuses in build & Start.
-  void InitializePipeline(PipelineStatus build_status,
-                          PipelineStatus start_status) {
-    // Expect an initialization callback.
     EXPECT_CALL(callbacks_, OnStart(start_status));
 
     pipeline_->Start(
-        mocks_->filter_collection(true, true, true, build_status).Pass(),
-        "",
+        mocks_->Create().Pass(),
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
         NetworkEventCB(),
         base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
-
     message_loop_.RunAllPending();
   }
 
   void CreateAudioStream() {
     audio_stream_ = CreateStream(DemuxerStream::AUDIO);
   }
 
   void CreateVideoStream() {
     video_stream_ = CreateStream(DemuxerStream::VIDEO);
   }
 
   MockDemuxerStream* audio_stream() {
     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(&RunPipelineStatusCB));
+        .WillOnce(Invoke(&RunPipelineStatusCB2));
 
     if (audio_stream_) {
       EXPECT_CALL(*mocks_->audio_renderer(), Seek(seek_time, _))
-          .WillOnce(Invoke(&RunPipelineStatusCB));
+          .WillOnce(Invoke(&RunPipelineStatusCB2));
     }
 
     if (video_stream_) {
       EXPECT_CALL(*mocks_->video_renderer(), Seek(seek_time, _))
-          .WillOnce(Invoke(&RunPipelineStatusCB));
+          .WillOnce(Invoke(&RunPipelineStatusCB2));
     }
 
     // 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 48 matching lines @@
   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());
 }
 
 TEST_F(PipelineTest, NeverInitializes) {
+  // Don't execute the callback passed into Initialize().
+  EXPECT_CALL(*mocks_->demuxer(), Initialize(_));
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
+      .WillOnce(Invoke(&RunStopFilterCallback));
+
   // This test hangs during initialization by never calling
   // InitializationComplete().  StrictMock<> will ensure that the callback is
   // never executed.
   pipeline_->Start(
-        mocks_->filter_collection(false, false, true, PIPELINE_OK).Pass(),
-        "",
+        mocks_->Create().Pass(),
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
         NetworkEventCB(),
         base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
   message_loop_.RunAllPending();
 
   EXPECT_FALSE(pipeline_->IsInitialized());
 
   // Because our callback will get executed when the test tears down, we'll
   // verify that nothing has been called, then set our expectation for the call
   // made during tear down.
   Mock::VerifyAndClear(&callbacks_);
   EXPECT_CALL(callbacks_, OnStart(PIPELINE_OK));
 }
 
 TEST_F(PipelineTest, RequiredFilterMissing) {
+  // TODO(acolwell,fischman): See TODO in URLNotFound below.
+  EXPECT_CALL(callbacks_, OnStart(PIPELINE_ERROR_REQUIRED_FILTER_MISSING));
   EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING));
 
-  // Sets up expectations on the callback and initializes the pipeline.  Called
-  // after tests have set expectations any filters they wish to use.
-  // Expect an initialization callback.
-  EXPECT_CALL(callbacks_, OnStart(PIPELINE_ERROR_REQUIRED_FILTER_MISSING));
+  // Create a filter collection with missing filter.
+  scoped_ptr<FilterCollection> collection(mocks_->Create());
+  collection->SetDemuxer(NULL);
 
-  // Create a filter collection with missing filter.
-  scoped_ptr<FilterCollection> collection(mocks_->filter_collection(
-      false, true, true, PIPELINE_ERROR_REQUIRED_FILTER_MISSING));
   pipeline_->Start(
-        collection.Pass(),
-        "",
-        base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
-        NetworkEventCB(),
-        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
+      collection.Pass(),
+      base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
+      base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
+      NetworkEventCB(),
+      base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
   message_loop_.RunAllPending();
 
   EXPECT_FALSE(pipeline_->IsInitialized());
 }
 
 TEST_F(PipelineTest, URLNotFound) {
   // TODO(acolwell,fischman): Since OnStart() is getting called with an error
   // code already, OnError() doesn't also need to get called.  Fix the pipeline
   // (and it's consumers!) so that OnError doesn't need to be called after
   // another callback has already reported the error.  Same applies to NoStreams
   // below.
   EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_URL_NOT_FOUND));
+
+  EXPECT_CALL(*mocks_->demuxer(), Initialize(_))
+      .WillOnce(RunPipelineStatusCBWithError(
+          PIPELINE_ERROR_URL_NOT_FOUND));
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
+      .WillOnce(Invoke(&RunStopFilterCallback));
+
   InitializePipeline(PIPELINE_ERROR_URL_NOT_FOUND);
   EXPECT_FALSE(pipeline_->IsInitialized());
 }
 
 TEST_F(PipelineTest, NoStreams) {
-  // Manually set these expectations because SetPlaybackRate() is not called if
-  // we cannot fully initialize the pipeline.
-  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(Invoke(&RunStopFilterCallback));
   // TODO(acolwell,fischman): see TODO in URLNotFound above.
   EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_COULD_NOT_RENDER));
 
-  InitializePipeline(PIPELINE_OK, PIPELINE_ERROR_COULD_NOT_RENDER);
+  EXPECT_CALL(*mocks_->demuxer(), Initialize(_))
+      .WillOnce(Invoke(&RunPipelineStatusCB));
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
+      .WillOnce(Invoke(&RunStopFilterCallback));
+
+  InitializePipeline(PIPELINE_ERROR_COULD_NOT_RENDER);
   EXPECT_FALSE(pipeline_->IsInitialized());
 }
 
 TEST_F(PipelineTest, AudioStream) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(audio_stream());
@@ skipping 511 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