Remove DemuxerFactory and URL parameter from Pipeline.

media/filters/ffmpeg_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 <deque>
 
 #include "base/file_path.h"
 #include "base/path_service.h"
 #include "base/threading/thread.h"
 #include "media/base/filters.h"
@@ skipping 23 matching lines @@
 MATCHER(IsEndOfStreamBuffer,
         std::string(negation ? "isn't" : "is") + " end of stream") {
   return arg->IsEndOfStream();
 }
 
 // Fixture class to facilitate writing tests.  Takes care of setting up the
 // FFmpeg, pipeline and filter host mocks.
 class FFmpegDemuxerTest : public testing::Test {
  protected:
 
-  FFmpegDemuxerTest() {
-    // Create an FFmpegDemuxer with local data source.
-    demuxer_ = new FFmpegDemuxer(&message_loop_, true);
-    demuxer_->disable_first_seek_hack_for_testing();
-
-    // Inject a filter host and message loop and prepare a data source.
-    demuxer_->set_host(&host_);
-
-    EXPECT_CALL(host_, SetTotalBytes(_)).Times(AnyNumber());
-    EXPECT_CALL(host_, SetBufferedBytes(_)).Times(AnyNumber());
-    EXPECT_CALL(host_, SetCurrentReadPosition(_))
-        .WillRepeatedly(SaveArg<0>(&current_read_position_));
-  }
+  FFmpegDemuxerTest() {}
 
   virtual ~FFmpegDemuxerTest() {
     if (demuxer_) {
       // Call Stop() to shut down internal threads.
       demuxer_->Stop(NewExpectedClosure());
     }
 
     // Finish up any remaining tasks.
     message_loop_.RunAllPending();
     // Release the reference to the demuxer.
     demuxer_ = NULL;
   }
 
-  scoped_refptr<FileDataSource> CreateDataSource(const std::string& name) {
-    return CreateDataSource(name, false);
+  void CreateDemuxer(const std::string& name) {
+    CreateDemuxer(name, false);
   }
 
-  scoped_refptr<FileDataSource> CreateDataSource(const std::string& name,
-                                                 bool disable_file_size) {
-    FilePath file_path;
-    EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &file_path));
+  void CreateDemuxer(const std::string& name, bool disable_file_size) {
+    CHECK(!demuxer_);
 
-    file_path = file_path.Append(FILE_PATH_LITERAL("media"))
-        .Append(FILE_PATH_LITERAL("test"))
-        .Append(FILE_PATH_LITERAL("data"))
-        .AppendASCII(name);
+    EXPECT_CALL(host_, SetTotalBytes(_)).Times(AnyNumber());
+    EXPECT_CALL(host_, SetBufferedBytes(_)).Times(AnyNumber());
+    EXPECT_CALL(host_, SetCurrentReadPosition(_))
+        .WillRepeatedly(SaveArg<0>(&current_read_position_));
 
-    scoped_refptr<FileDataSource> data_source = new FileDataSource(
-        disable_file_size);
+    CreateDataSource(name, disable_file_size);
 
-    EXPECT_EQ(PIPELINE_OK, data_source->Initialize(file_path.MaybeAsASCII()));
+    // Create an FFmpegDemuxer with local data source.
+    demuxer_ = new FFmpegDemuxer(&message_loop_, data_source_, true);
+    demuxer_->disable_first_seek_hack_for_testing();
 
-    return data_source.get();
+    // Inject a filter host and message loop and prepare a data source.
+    demuxer_->set_host(&host_);
   }
 
   MOCK_METHOD1(CheckPoint, void(int v));
 
-  // Initializes FFmpegDemuxer.
-  void InitializeDemuxer(const scoped_refptr<DataSource>& data_source) {
+  void InitializeDemuxer() {
     EXPECT_CALL(host_, SetDuration(_));
-    demuxer_->Initialize(data_source, NewExpectedStatusCB(PIPELINE_OK));
+    demuxer_->Initialize(NewExpectedStatusCB(PIPELINE_OK));
     message_loop_.RunAllPending();
   }
 
   // Verifies that |buffer| has a specific |size| and |timestamp|.
   // |location| simply indicates where the call to this function was made.
   // This makes it easier to track down where test failures occur.
   void ValidateBuffer(const tracked_objects::Location& location,
                       const scoped_refptr<Buffer>& buffer,
                       int size, int64 timestampInMicroseconds) {
     std::string location_str;
     location.Write(true, false, &location_str);
     location_str += "\n";
     SCOPED_TRACE(location_str);
     EXPECT_TRUE(buffer.get() != NULL);
     EXPECT_EQ(size, buffer->GetDataSize());
     EXPECT_EQ(base::TimeDelta::FromMicroseconds(timestampInMicroseconds),
               buffer->GetTimestamp());
   }
 
   // Creates a data source with the given |file_name|. If |disable_file_size|
   // then the data source pretends it does not know the file size (e.g. often
   // when streaming video). Uses this data source to initialize a demuxer, then
   // returns true if the bitrate is valid, false otherwise.
   bool VideoHasValidBitrate(
       const std::string& file_name, bool disable_file_size) {
-    scoped_refptr<FileDataSource> data_source =
-        CreateDataSource(file_name, disable_file_size);
-    InitializeDemuxer(data_source);
+    CreateDemuxer(file_name, disable_file_size);
+    InitializeDemuxer();
     return demuxer_->GetBitrate() > 0;
   }
 
   bool IsStreamStopped(DemuxerStream::Type type) {
     DemuxerStream* stream = demuxer_->GetStream(type);
     CHECK(stream);
     return static_cast<FFmpegDemuxerStream*>(stream)->stopped_;
   }
 
   // Fixture members.
+  scoped_refptr<FileDataSource> data_source_;
   scoped_refptr<FFmpegDemuxer> demuxer_;
   StrictMock<MockDemuxerHost> host_;
   MessageLoop message_loop_;
 
   int64 current_read_position_;
 
  private:
+  void CreateDataSource(const std::string& name, bool disable_file_size) {
+    CHECK(!data_source_);
+
+    FilePath file_path;
+    EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &file_path));
+
+    file_path = file_path.Append(FILE_PATH_LITERAL("media"))
+        .Append(FILE_PATH_LITERAL("test"))
+        .Append(FILE_PATH_LITERAL("data"))
+        .AppendASCII(name);
+
+    data_source_ = new FileDataSource(disable_file_size);
+    EXPECT_EQ(PIPELINE_OK, data_source_->Initialize(file_path.MaybeAsASCII()));
+  }
+
   DISALLOW_COPY_AND_ASSIGN(FFmpegDemuxerTest);
 };
 
 TEST_F(FFmpegDemuxerTest, Initialize_OpenFails) {
   // Simulate avformat_open_input() failing.
+  CreateDemuxer("ten_byte_file"),
   EXPECT_CALL(host_, SetCurrentReadPosition(_));
-  demuxer_->Initialize(CreateDataSource("ten_byte_file"),
-                       NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
+  demuxer_->Initialize(NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
 
   message_loop_.RunAllPending();
 }
 
 // TODO(acolwell): Uncomment this test when we discover a file that passes
 // avformat_open_input(), but has avformat_find_stream_info() fail.
 //
 //TEST_F(FFmpegDemuxerTest, Initialize_ParseFails) {
+//  CreateDemuxer("find_stream_info_fail.webm");
 //  demuxer_->Initialize(
-//      CreateDataSource("find_stream_info_fail.webm"),
 //      NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_PARSE));
 //  message_loop_.RunAllPending();
 //}
 
 TEST_F(FFmpegDemuxerTest, Initialize_NoStreams) {
   // Open a file with no streams whatsoever.
+  CreateDemuxer("no_streams.webm");
   EXPECT_CALL(host_, SetCurrentReadPosition(_));
   demuxer_->Initialize(
-      CreateDataSource("no_streams.webm"),
       NewExpectedStatusCB(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
   message_loop_.RunAllPending();
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_NoAudioVideo) {
   // Open a file containing streams but none of which are audio/video streams.
+  CreateDemuxer("no_audio_video.webm");
   demuxer_->Initialize(
-      CreateDataSource("no_audio_video.webm"),
       NewExpectedStatusCB(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
   message_loop_.RunAllPending();
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_Successful) {
-  InitializeDemuxer(CreateDataSource("bear-320x240.webm"));
+  CreateDemuxer("bear-320x240.webm");
+  InitializeDemuxer();
 
   // Video stream should be present.
   scoped_refptr<DemuxerStream> stream =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(stream);
   EXPECT_EQ(DemuxerStream::VIDEO, stream->type());
 
   const VideoDecoderConfig& video_config = stream->video_decoder_config();
   EXPECT_EQ(kCodecVP8, video_config.codec());
   EXPECT_EQ(VideoFrame::YV12, video_config.format());
@@ skipping 29 matching lines @@
 
 TEST_F(FFmpegDemuxerTest, Initialize_Multitrack) {
   // Open a file containing the following streams:
   //   Stream #0: Video (VP8)
   //   Stream #1: Audio (Vorbis)
   //   Stream #2: Subtitles (SRT)
   //   Stream #3: Video (Theora)
   //   Stream #4: Audio (16-bit signed little endian PCM)
   //
   // We should only pick the first audio/video streams we come across.
-  InitializeDemuxer(CreateDataSource("bear-320x240-multitrack.webm"));
+  CreateDemuxer("bear-320x240-multitrack.webm");
+  InitializeDemuxer();
 
   // Video stream should be VP8.
   scoped_refptr<DemuxerStream> stream =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(stream);
   EXPECT_EQ(DemuxerStream::VIDEO, stream->type());
   EXPECT_EQ(kCodecVP8, stream->video_decoder_config().codec());
 
   // Audio stream should be Vorbis.
   stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(stream);
   EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
   EXPECT_EQ(kCodecVorbis, stream->audio_decoder_config().codec());
 
   // Unknown stream should never be present.
   EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::UNKNOWN));
 }
 
 TEST_F(FFmpegDemuxerTest, Read_Audio) {
   // We test that on a successful audio packet read.
-  InitializeDemuxer(CreateDataSource("bear-320x240.webm"));
+  CreateDemuxer("bear-320x240.webm");
+  InitializeDemuxer();
 
   // Attempt a read from the audio stream and run the message loop until done.
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
   reader->Read(audio);
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ValidateBuffer(FROM_HERE, reader->buffer(), 29, 0);
 
   reader->Reset();
   reader->Read(audio);
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ValidateBuffer(FROM_HERE, reader->buffer(), 27, 3000);
 }
 
 TEST_F(FFmpegDemuxerTest, Read_Video) {
   // We test that on a successful video packet read.
-  InitializeDemuxer(CreateDataSource("bear-320x240.webm"));
+  CreateDemuxer("bear-320x240.webm");
+  InitializeDemuxer();
 
   // Attempt a read from the video stream and run the message loop until done.
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
 
   reader->Read(video);
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ValidateBuffer(FROM_HERE, reader->buffer(), 22084, 0);
 
   reader->Reset();
   reader->Read(video);
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ValidateBuffer(FROM_HERE, reader->buffer(), 1057, 33000);
 }
 
 TEST_F(FFmpegDemuxerTest, Read_VideoNonZeroStart) {
   // Test the start time is the first timestamp of the video and audio stream.
-  InitializeDemuxer(CreateDataSource("nonzero-start-time.webm"));
+  CreateDemuxer("nonzero-start-time.webm");
+  InitializeDemuxer();
 
   // Attempt a read from the video stream and run the message loop until done.
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
 
   // Check first buffer in video stream.
   reader->Read(video);
@@ skipping 10 matching lines @@
   ValidateBuffer(FROM_HERE, reader->buffer(), 165, 396000);
   const base::TimeDelta audio_timestamp = reader->buffer()->GetTimestamp();
 
   // Verify that the start time is equal to the lowest timestamp.
   EXPECT_EQ(std::min(audio_timestamp, video_timestamp),
             demuxer_->GetStartTime());
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EndOfStream) {
   // Verify that end of stream buffers are created.
-  InitializeDemuxer(CreateDataSource("bear-320x240.webm"));
+  CreateDemuxer("bear-320x240.webm");
+  InitializeDemuxer();
 
   // We should now expect an end of stream buffer.
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
 
   bool got_eos_buffer = false;
   const int kMaxBuffers = 170;
   for (int i = 0; !got_eos_buffer && i < kMaxBuffers; i++) {
     reader->Read(audio);
@@ skipping 12 matching lines @@
     EXPECT_GT(reader->buffer()->GetDataSize(), 0);
     reader->Reset();
   }
 
   EXPECT_TRUE(got_eos_buffer);
 }
 
 TEST_F(FFmpegDemuxerTest, Seek) {
   // We're testing that the demuxer frees all queued packets when it receives
   // a Seek().
-  InitializeDemuxer(CreateDataSource("bear-320x240.webm"));
+  CreateDemuxer("bear-320x240.webm");
+  InitializeDemuxer();
 
   // Get our streams.
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(video);
   ASSERT_TRUE(audio);
 
   // Read a video packet and release it.
@@ skipping 57 matching lines @@
   MOCK_METHOD0(OnDelete, void());
   MOCK_METHOD1(Run, void(const scoped_refptr<Buffer>& buffer));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockReadCB);
 };
 
 TEST_F(FFmpegDemuxerTest, Stop) {
   // Tests that calling Read() on a stopped demuxer stream immediately deletes
   // the callback.
-  InitializeDemuxer(CreateDataSource("bear-320x240.webm"));
+  CreateDemuxer("bear-320x240.webm");
+  InitializeDemuxer();
 
   // Get our stream.
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(audio);
 
   demuxer_->Stop(NewExpectedClosure());
 
   // Expect all calls in sequence.
   InSequence s;
@@ skipping 15 matching lines @@
 
   // ...and verify that |callback| was deleted.
   CheckPoint(1);
 }
 
 // The streams can outlive the demuxer because the streams may still be in use
 // by the decoder when the demuxer is destroyed.
 // This test verifies that DemuxerStream::Read() does not use an invalid demuxer
 // pointer (no crash occurs) and calls the callback with an EndOfStream buffer.
 TEST_F(FFmpegDemuxerTest, StreamReadAfterStopAndDemuxerDestruction) {
-  InitializeDemuxer(CreateDataSource("bear-320x240.webm"));
+  CreateDemuxer("bear-320x240.webm");
+  InitializeDemuxer();
 
   // Get our stream.
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(audio);
 
   demuxer_->Stop(NewExpectedClosure());
 
   // Finish up any remaining tasks.
   message_loop_.RunAllPending();
@@ skipping 22 matching lines @@
 
   // ...and verify that |callback| was deleted.
   CheckPoint(1);
 }
 
 TEST_F(FFmpegDemuxerTest, DisableAudioStream) {
   // We are doing the following things here:
   // 1. Initialize the demuxer with audio and video stream.
   // 2. Send a "disable audio stream" message to the demuxer.
   // 3. Demuxer will free audio packets even if audio stream was initialized.
-  InitializeDemuxer(CreateDataSource("bear-320x240.webm"));
+  CreateDemuxer("bear-320x240.webm");
+  InitializeDemuxer();
 
   // Submit a "disable audio stream" message to the demuxer.
   demuxer_->OnAudioRendererDisabled();
   message_loop_.RunAllPending();
 
   // Get our streams.
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
@@ skipping 14 matching lines @@
   // Attempt a read from the audio stream: it should immediately return end of
   // stream without requiring the message loop to read data.
   reader->Reset();
   reader->Read(audio);
   ASSERT_TRUE(reader->called());
   EXPECT_TRUE(reader->buffer()->IsEndOfStream());
 }
 
 class MockFFmpegDemuxer : public FFmpegDemuxer {
  public:
-  explicit MockFFmpegDemuxer(MessageLoop* message_loop)
-      : FFmpegDemuxer(message_loop, true) {
+  MockFFmpegDemuxer(MessageLoop* message_loop,
+                    const scoped_refptr<DataSource>& data_source)
+      : FFmpegDemuxer(message_loop, data_source, true) {
   }
   virtual ~MockFFmpegDemuxer() {}
 
   MOCK_METHOD0(WaitForRead, int());
   MOCK_METHOD1(SignalReadCompleted, void(int size));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockFFmpegDemuxer);
 };
 
 // A gmock helper method to execute the callback and deletes it.
 void RunCallback(int size, const DataSource::ReadCB& callback) {
   DCHECK(!callback.is_null());
   callback.Run(size);
 }
 
 TEST_F(FFmpegDemuxerTest, ProtocolRead) {
   scoped_refptr<StrictMock<MockDataSource> > data_source =
       new StrictMock<MockDataSource>();
 
   EXPECT_CALL(*data_source, Stop(_))
       .WillRepeatedly(Invoke(&RunStopFilterCallback));
 
   // Creates a demuxer.
   scoped_refptr<MockFFmpegDemuxer> demuxer(
-      new MockFFmpegDemuxer(&message_loop_));
-  ASSERT_TRUE(demuxer);
+      new MockFFmpegDemuxer(&message_loop_, data_source));
   demuxer->set_host(&host_);
-  demuxer->data_source_ = data_source;
 
   uint8 kBuffer[1];
   InSequence s;
   // Actions taken in the first read.
   EXPECT_CALL(*data_source, GetSize(_))
       .WillOnce(DoAll(SetArgPointee<0>(1024), Return(true)));
   EXPECT_CALL(*data_source, Read(0, 512, kBuffer, _))
       .WillOnce(WithArgs<1, 3>(Invoke(&RunCallback)));
   EXPECT_CALL(*demuxer, SignalReadCompleted(512));
   EXPECT_CALL(*demuxer, WaitForRead())
@@ skipping 44 matching lines @@
 
 TEST_F(FFmpegDemuxerTest, GetBitrate_SetInContainer_NoFileSize) {
   EXPECT_TRUE(VideoHasValidBitrate("bear.ogv", true));
 }
 
 TEST_F(FFmpegDemuxerTest, GetBitrate_UnsetInContainer_NoFileSize) {
   EXPECT_TRUE(VideoHasValidBitrate("bear-320x240.webm", true));
 }
 
 TEST_F(FFmpegDemuxerTest, ProtocolGetSetPosition) {
-  scoped_refptr<DataSource> data_source = CreateDataSource("bear-320x240.webm");
-  InitializeDemuxer(data_source);
+  CreateDemuxer("bear-320x240.webm");
+  InitializeDemuxer();
 
   InSequence s;
 
   int64 size;
   int64 position;
   EXPECT_TRUE(demuxer_->GetSize(&size));
   EXPECT_TRUE(demuxer_->GetPosition(&position));
   EXPECT_EQ(current_read_position_, position);
 
   EXPECT_TRUE(demuxer_->SetPosition(512));
   EXPECT_FALSE(demuxer_->SetPosition(size));
   EXPECT_FALSE(demuxer_->SetPosition(size + 1));
   EXPECT_FALSE(demuxer_->SetPosition(-1));
   EXPECT_TRUE(demuxer_->GetPosition(&position));
   EXPECT_EQ(512, position);
 }
 
 TEST_F(FFmpegDemuxerTest, ProtocolGetSize) {
-  scoped_refptr<DataSource> data_source = CreateDataSource("bear-320x240.webm");
-  InitializeDemuxer(data_source);
+  CreateDemuxer("bear-320x240.webm");
+  InitializeDemuxer();
 
   int64 data_source_size = 0;
   int64 demuxer_size = 0;
-  EXPECT_TRUE(data_source->GetSize(&data_source_size));
+  EXPECT_TRUE(data_source_->GetSize(&data_source_size));
   EXPECT_TRUE(demuxer_->GetSize(&demuxer_size));
   EXPECT_NE(0, data_source_size);
   EXPECT_EQ(data_source_size, demuxer_size);
 }
 
 TEST_F(FFmpegDemuxerTest, ProtocolIsStreaming) {
-  scoped_refptr<DataSource> data_source = CreateDataSource("bear-320x240.webm");
-  InitializeDemuxer(data_source);
+  CreateDemuxer("bear-320x240.webm");
+  InitializeDemuxer();
 
-  EXPECT_FALSE(data_source->IsStreaming());
+  EXPECT_FALSE(data_source_->IsStreaming());
   EXPECT_FALSE(demuxer_->IsStreaming());
 }
 
 // Verify that seek works properly when the WebM cues data is at the start of
 // the file instead of at the end.
 TEST_F(FFmpegDemuxerTest, SeekWithCuesBeforeFirstCluster) {
-  InitializeDemuxer(CreateDataSource("bear-320x240-cues-in-front.webm"));
+  CreateDemuxer("bear-320x240-cues-in-front.webm");
+  InitializeDemuxer();
 
   // Get our streams.
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(video);
   ASSERT_TRUE(audio);
 
   // Read a video packet and release it.
@@ skipping 38 matching lines @@
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ValidateBuffer(FROM_HERE, reader->buffer(), 1740, 2436000);
 
   // Manually release the last reference to the buffer and verify it was freed.
   reader->Reset();
   message_loop_.RunAllPending();
 }
 
 }  // namespace media