Remove DemuxerFactory and URL parameter from Pipeline.

media/filters/chunk_demuxer_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 "base/bind.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_demuxer_host.h"
 #include "media/base/test_data_util.h"
 #include "media/filters/chunk_demuxer.h"
@@ skipping 72 matching lines @@
  protected:
   enum CodecsIndex {
     AUDIO,
     VIDEO,
     MAX_CODECS_INDEX
   };
 
   ChunkDemuxerTest()
       : client_(new MockChunkDemuxerClient()),
         demuxer_(new ChunkDemuxer(client_.get())) {
+    demuxer_->set_host(&mock_demuxer_host_);
   }
 
   virtual ~ChunkDemuxerTest() {
     ShutdownDemuxer();
   }
 
   void CreateInfoTracks(bool has_audio, bool has_video,
                         bool video_content_encoded, scoped_array<uint8>* buffer,
                         int* size) {
     scoped_array<uint8> info;
@@ skipping 83 matching lines @@
 
   bool AppendInfoTracks(bool has_audio, bool has_video,
                         bool video_content_encoded) {
     scoped_array<uint8> info_tracks;
     int info_tracks_size = 0;
     CreateInfoTracks(has_audio, has_video, video_content_encoded,
                      &info_tracks, &info_tracks_size);
     return AppendData(info_tracks.get(), info_tracks_size);
   }
 
-  void InitDoneCalled(const base::TimeDelta& expected_duration,
-                      PipelineStatus expected_status,
-                      bool call_set_host,
+  void InitDoneCalled(PipelineStatus expected_status,
                       PipelineStatus status) {
     EXPECT_EQ(status, expected_status);
+  }
 
-    if (status == PIPELINE_OK) {
+  PipelineStatusCB CreateInitDoneCB(const base::TimeDelta& expected_duration,
+                                    PipelineStatus expected_status) {
+    if (expected_status == PIPELINE_OK) {
       EXPECT_CALL(mock_demuxer_host_, SetDuration(expected_duration));
       EXPECT_CALL(mock_demuxer_host_, SetCurrentReadPosition(_));
+    }
 
-      if (call_set_host)
-        demuxer_->set_host(&mock_demuxer_host_);
-    }
-  }
-
-  PipelineStatusCB CreateInitDoneCB(const base::TimeDelta& duration,
-                                    PipelineStatus expected_status,
-                                    bool call_set_host) {
     return base::Bind(&ChunkDemuxerTest::InitDoneCalled,
                       base::Unretained(this),
-                      duration,
-                      expected_status,
-                      call_set_host);
+                      expected_status);
   }
 
   bool InitDemuxer(bool has_audio, bool has_video,
                    bool video_content_encoded) {
     PipelineStatus expected_status =
         (has_audio || has_video) ? PIPELINE_OK : DEMUXER_ERROR_COULD_NOT_OPEN;
 
     EXPECT_CALL(*client_, DemuxerOpened(_));
-    demuxer_->Init(CreateInitDoneCB(kDefaultDuration(), expected_status, true));
+    demuxer_->Initialize(CreateInitDoneCB(
+        kDefaultDuration(), expected_status));
 
     return AppendInfoTracks(has_audio, has_video, video_content_encoded);
   }
 
   void ShutdownDemuxer() {
     if (demuxer_) {
       EXPECT_CALL(*client_, DemuxerClosed());
       demuxer_->Shutdown();
     }
   }
@@ skipping 31 matching lines @@
   //    a timestamp of kSkip indicates that a Read() call for that stream
   //    shouldn't be made on that iteration of the loop. If both streams have
   //    a kSkip then the loop will terminate.
   bool ParseWebMFile(const std::string& filename,
                      const BufferTimestamps* timestamps,
                      const base::TimeDelta& duration) {
     scoped_array<uint8> buffer;
     int buffer_size = 0;
 
     EXPECT_CALL(*client_, DemuxerOpened(_));
-    demuxer_->Init(CreateInitDoneCB(duration, PIPELINE_OK, true));
+    demuxer_->Initialize(CreateInitDoneCB(duration, PIPELINE_OK));
 
     // Read a WebM file into memory and send the data to the demuxer.
     ReadTestDataFile(filename, &buffer, &buffer_size);
     if (!AppendDataInPieces(buffer.get(), buffer_size, 512))
       return false;
 
     scoped_refptr<DemuxerStream> audio =
         demuxer_->GetStream(DemuxerStream::AUDIO);
     scoped_refptr<DemuxerStream> video =
         demuxer_->GetStream(DemuxerStream::VIDEO);
@@ skipping 46 matching lines @@
     bool has_audio = (i & 0x1) != 0;
     bool has_video = (i & 0x2) != 0;
     bool video_content_encoded = (i & 0x4) != 0;
 
     // No test on invalid combination.
     if (!has_video && video_content_encoded)
       continue;
 
     client_.reset(new MockChunkDemuxerClient());
     demuxer_ = new ChunkDemuxer(client_.get());
+    demuxer_->set_host(&mock_demuxer_host_);
     ASSERT_TRUE(InitDemuxer(has_audio, has_video, video_content_encoded));
 
     scoped_refptr<DemuxerStream> audio_stream =
         demuxer_->GetStream(DemuxerStream::AUDIO);
     if (has_audio) {
       ASSERT_TRUE(audio_stream);
 
       const AudioDecoderConfig& config = audio_stream->audio_decoder_config();
       EXPECT_EQ(kCodecVorbis, config.codec());
       EXPECT_EQ(16, config.bits_per_channel());
@@ skipping 276 matching lines @@
   AddSimpleBlock(&cb, kAudioTrackNum, 10);
   AddSimpleBlock(&cb, kVideoTrackNum, 10);
   scoped_ptr<Cluster> cluster_c(cb.Finish());
   EXPECT_FALSE(demuxer_->AppendData(cluster_c->data(), cluster_c->size()));
 }
 
 // Test the case where a cluster is passed to AppendData() before
 // INFO & TRACKS data.
 TEST_F(ChunkDemuxerTest, TestClusterBeforeInfoTracks) {
   EXPECT_CALL(*client_, DemuxerOpened(_));
-  demuxer_->Init(NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
+  demuxer_->Initialize(NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
 
   ClusterBuilder cb;
   cb.SetClusterTimecode(0);
   AddSimpleBlock(&cb, kVideoTrackNum, 0);
   scoped_ptr<Cluster> cluster(cb.Finish());
 
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 }
 
 // Test cases where we get an EndOfStream() call during initialization.
 TEST_F(ChunkDemuxerTest, TestEOSDuringInit) {
   EXPECT_CALL(*client_, DemuxerOpened(_));
-  demuxer_->Init(NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
+  demuxer_->Initialize(NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
   demuxer_->EndOfStream(PIPELINE_OK);
 }
 
 TEST_F(ChunkDemuxerTest, TestDecodeErrorEndOfStream) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   ClusterBuilder cb;
   cb.SetClusterTimecode(0);
   AddSimpleBlock(&cb, kAudioTrackNum, 0);
   AddSimpleBlock(&cb, kVideoTrackNum, 0);
@@ skipping 163 matching lines @@
   end_of_stream_helper_2.CheckIfReadDonesWereCalled(true);
 
   end_of_stream_helper_3.RequestReads();
   end_of_stream_helper_3.CheckIfReadDonesWereCalled(true);
 }
 
 // Make sure AppendData() will accept elements that span multiple calls.
 TEST_F(ChunkDemuxerTest, TestAppendingInPieces) {
 
   EXPECT_CALL(*client_, DemuxerOpened(_));
-  demuxer_->Init(CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK, true));
+  demuxer_->Initialize(CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
 
   scoped_array<uint8> info_tracks;
   int info_tracks_size = 0;
   CreateInfoTracks(true, true, false, &info_tracks, &info_tracks_size);
 
   ClusterBuilder cb;
   cb.SetClusterTimecode(0);
   AddSimpleBlock(&cb, kAudioTrackNum, 32, 512);
   AddSimpleBlock(&cb, kVideoTrackNum, 123, 1024);
   scoped_ptr<Cluster> cluster_a(cb.Finish());
@@ skipping 174 matching lines @@
 
   // Append the remaining data.
   ASSERT_TRUE(AppendData(cluster->data() + i, cluster->size() - i));
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 
 TEST_F(ChunkDemuxerTest, TestParseErrorDuringInit) {
+  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
+
   EXPECT_CALL(*client_, DemuxerOpened(_));
-  demuxer_->Init(CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK, false));
+  demuxer_->Initialize(CreateInitDoneCB(
+      kDefaultDuration(), PIPELINE_OK));
   ASSERT_TRUE(AppendInfoTracks(true, true, false));
 
   uint8 tmp = 0;
   ASSERT_TRUE(demuxer_->AppendData(&tmp, 1));
-
-  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
-  demuxer_->set_host(&mock_demuxer_host_);
 }
 
 }  // namespace media