Refactored FFmpegDemuxerTest to use a test fixture, fixing flakiness in the process.

media/filters/ffmpeg_demuxer_unittest.cc

 // Copyright (c) 2009 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/singleton.h"
 #include "base/tuple.h"
 #include "media/base/filter_host.h"
 #include "media/base/filters.h"
@@ skipping 147 matching lines @@
   g_seek_event->Signal();
   return g_av_seek_frame;
 }
 
 }  // extern "C"
 
 using namespace media;
 
 namespace {
 
-void InitializeFFmpegMocks() {
-  // Initialize function return codes.
-  g_av_open_input_file = 0;
-  g_av_find_stream_info = 0;
-  g_av_read_frame = 0;
-
-  // Initialize AVFormatContext structure.
-  memset(&g_format, 0, sizeof(g_format));
-
-  // Initialize AVStream structures.
-  for (size_t i = 0; i < kMaxStreams; ++i) {
-    memset(&g_streams[i], 0, sizeof(g_streams[i]));
-    g_streams[i].time_base.den = 1 * base::Time::kMicrosecondsPerSecond;
-    g_streams[i].time_base.num = 1;
-  }
-
-  // Initialize AVCodexContext structures.
-  memset(&g_audio_codec, 0, sizeof(g_audio_codec));
-  g_audio_codec.codec_type = CODEC_TYPE_AUDIO;
-  g_audio_codec.codec_id = CODEC_ID_VORBIS;
-  g_audio_codec.channels = 2;
-  g_audio_codec.sample_rate = 44100;
-
-  memset(&g_video_codec, 0, sizeof(g_video_codec));
-  g_video_codec.codec_type = CODEC_TYPE_VIDEO;
-  g_video_codec.codec_id = CODEC_ID_THEORA;
-  g_video_codec.height = 720;
-  g_video_codec.width = 1280;
-
-  memset(&g_data_codec, 0, sizeof(g_data_codec));
-  g_data_codec.codec_type = CODEC_TYPE_DATA;
-  g_data_codec.codec_id = CODEC_ID_NONE;
-}
-
 // Ref counted object so we can create callbacks to call DemuxerStream::Read().
 class TestReader : public base::RefCountedThreadSafe<TestReader> {
  public:
   TestReader()
       : called_(false),
         expecting_call_(false),
         wait_for_read_(false, false) {
   }
 
   virtual ~TestReader() {}
@@ skipping 31 matching lines @@
   bool called() { return called_; }
   bool expecting_call() { return expecting_call_; }
 
  private:
   scoped_refptr<Buffer> buffer_;
   bool called_;
   bool expecting_call_;
   base::WaitableEvent wait_for_read_;
 };
 
+// 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() {}
+  virtual ~FFmpegDemuxerTest() {}
+
+  virtual void SetUp() {
+    InitializeFFmpegMocks();
+
+    // Create an FFmpegDemuxer.
+    factory_ = FFmpegDemuxer::CreateFilterFactory();
+    MediaFormat media_format;
+    media_format.SetAsString(MediaFormat::kMimeType,
+                             mime_type::kApplicationOctetStream);
+    demuxer_ = factory_->Create<Demuxer>(media_format);
+    DCHECK(demuxer_);
+
+    // Prepare a filter host and data source for the demuxer.
+    pipeline_.reset(new MockPipeline());
+    filter_host_.reset(new MockFilterHost<Demuxer>(pipeline_.get(), demuxer_));
+    MockFilterConfig config;
+    data_source_ = new MockDataSource(&config);
+  }
+
+  virtual void TearDown() {
+    // Call Stop() to shut down internal threads.
+    demuxer_->Stop();
+  }
+
+  // Fixture members.
+  scoped_refptr<FilterFactory> factory_;
+  scoped_refptr<Demuxer> demuxer_;
+  scoped_ptr<MockPipeline> pipeline_;
+  scoped_ptr< MockFilterHost<Demuxer> > filter_host_;
+  scoped_refptr<MockDataSource> data_source_;
+
+ private:
+  static void InitializeFFmpegMocks() {
+    // Initialize function return codes.
+    g_av_open_input_file = 0;
+    g_av_find_stream_info = 0;
+    g_av_read_frame = 0;
+
+    // Initialize AVFormatContext structure.
+    memset(&g_format, 0, sizeof(g_format));
+
+    // Initialize AVStream structures.
+    for (size_t i = 0; i < kMaxStreams; ++i) {
+      memset(&g_streams[i], 0, sizeof(g_streams[i]));
+      g_streams[i].time_base.den = 1 * base::Time::kMicrosecondsPerSecond;
+      g_streams[i].time_base.num = 1;
+    }
+
+    // Initialize AVCodexContext structures.
+    memset(&g_audio_codec, 0, sizeof(g_audio_codec));
+    g_audio_codec.codec_type = CODEC_TYPE_AUDIO;
+    g_audio_codec.codec_id = CODEC_ID_VORBIS;
+    g_audio_codec.channels = 2;
+    g_audio_codec.sample_rate = 44100;
+
+    memset(&g_video_codec, 0, sizeof(g_video_codec));
+    g_video_codec.codec_type = CODEC_TYPE_VIDEO;
+    g_video_codec.codec_id = CODEC_ID_THEORA;
+    g_video_codec.height = 720;
+    g_video_codec.width = 1280;
+
+    memset(&g_data_codec, 0, sizeof(g_data_codec));
+    g_data_codec.codec_type = CODEC_TYPE_DATA;
+    g_data_codec.codec_id = CODEC_ID_NONE;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(FFmpegDemuxerTest);
+};
+
 }  // namespace
 
-// TODO(scherkus): http://crbug.com/10863
-TEST(FFmpegDemuxerTest, DISABLED_InitializeFailure) {
-  InitializeFFmpegMocks();
-
-  // Get FFmpegDemuxer's filter factory.
+TEST(FFmpegDemuxerFactoryTest, Create) {
+  // Should only accept application/octet-stream type.
   scoped_refptr<FilterFactory> factory = FFmpegDemuxer::CreateFilterFactory();
-
-  // Should only accept application/octet-stream type.
   MediaFormat media_format;
   media_format.SetAsString(MediaFormat::kMimeType, "foo/x-bar");
   scoped_refptr<Demuxer> demuxer(factory->Create<Demuxer>(media_format));
   ASSERT_FALSE(demuxer);
+
+  // Try again with application/octet-stream mime type.
   media_format.Clear();
   media_format.SetAsString(MediaFormat::kMimeType,
                            mime_type::kApplicationOctetStream);
   demuxer = factory->Create<Demuxer>(media_format);
   ASSERT_TRUE(demuxer);
+}
 
-  // Prepare a filter host and data source for the demuxer.
-  MockPipeline pipeline;
-  scoped_ptr< MockFilterHost<Demuxer> > filter_host;
-  filter_host.reset(new MockFilterHost<Demuxer>(&pipeline, demuxer));
-  MockFilterConfig config;
-  scoped_refptr<MockDataSource> data_source(new MockDataSource(&config));
-
+TEST_F(FFmpegDemuxerTest, InitializeCouldNotOpen) {
   // Simulate av_open_input_fail failing.
   g_av_open_input_file = AVERROR_IO;
   g_av_find_stream_info = 0;
-  EXPECT_TRUE(demuxer->Initialize(data_source));
-  EXPECT_TRUE(filter_host->WaitForError(DEMUXER_ERROR_COULD_NOT_OPEN));
-  EXPECT_FALSE(filter_host->IsInitialized());
+  EXPECT_TRUE(demuxer_->Initialize(data_source_.get()));
+  EXPECT_TRUE(filter_host_->WaitForError(DEMUXER_ERROR_COULD_NOT_OPEN));
+  EXPECT_FALSE(filter_host_->IsInitialized());
+}
 
+TEST_F(FFmpegDemuxerTest, InitializeCouldNotParse) {
   // Simulate av_find_stream_info failing.
   g_av_open_input_file = 0;
   g_av_find_stream_info = AVERROR_IO;
-  pipeline.Reset(false);
-  demuxer = factory->Create<Demuxer>(media_format);
-  filter_host.reset(new MockFilterHost<Demuxer>(&pipeline, demuxer));
-  EXPECT_TRUE(demuxer->Initialize(data_source));
-  EXPECT_TRUE(filter_host->WaitForError(DEMUXER_ERROR_COULD_NOT_PARSE));
-  EXPECT_FALSE(filter_host->IsInitialized());
 
+  EXPECT_TRUE(demuxer_->Initialize(data_source_.get()));
+  EXPECT_TRUE(filter_host_->WaitForError(DEMUXER_ERROR_COULD_NOT_PARSE));
+  EXPECT_FALSE(filter_host_->IsInitialized());
+}
+
+TEST_F(FFmpegDemuxerTest, InitializeNoStreams) {
   // Simulate media with no parseable streams.
-  InitializeFFmpegMocks();
-  pipeline.Reset(false);
-  demuxer = factory->Create<Demuxer>(media_format);
-  filter_host.reset(new MockFilterHost<Demuxer>(&pipeline, demuxer));
-  EXPECT_TRUE(demuxer->Initialize(data_source));
-  EXPECT_TRUE(filter_host->WaitForError(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
-  EXPECT_FALSE(filter_host->IsInitialized());
+  EXPECT_TRUE(demuxer_->Initialize(data_source_.get()));
+  EXPECT_TRUE(filter_host_->WaitForError(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
+  EXPECT_FALSE(filter_host_->IsInitialized());
+}
 
+TEST_F(FFmpegDemuxerTest, InitializeDataStreamOnly) {
   // Simulate media with a data stream but no audio or video streams.
   g_format.nb_streams = 1;
   g_format.streams[0] = &g_streams[0];
   g_streams[0].codec = &g_data_codec;
   g_streams[0].duration = 10;
-  pipeline.Reset(false);
-  demuxer = factory->Create<Demuxer>(media_format);
-  filter_host.reset(new MockFilterHost<Demuxer>(&pipeline, demuxer));
-  EXPECT_TRUE(demuxer->Initialize(data_source));
-  EXPECT_TRUE(filter_host->WaitForError(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
-  EXPECT_FALSE(filter_host->IsInitialized());
+
+  EXPECT_TRUE(demuxer_->Initialize(data_source_.get()));
+  EXPECT_TRUE(filter_host_->WaitForError(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
+  EXPECT_FALSE(filter_host_->IsInitialized());
 }
 
-// TODO(scherkus): http://crbug.com/10863
-TEST(FFmpegDemuxerTest, DISABLED_InitializeStreams) {
+TEST_F(FFmpegDemuxerTest, InitializeStreams) {
   // Simulate media with a data stream, a video stream and audio stream.
-  InitializeFFmpegMocks();
   g_format.nb_streams = 3;
   g_format.streams[0] = &g_streams[0];
   g_format.streams[1] = &g_streams[1];
   g_format.streams[2] = &g_streams[2];
   g_streams[0].duration = 1000;
   g_streams[0].codec = &g_data_codec;
   g_streams[1].duration = 100;
   g_streams[1].codec = &g_video_codec;
   g_streams[2].duration = 10;
   g_streams[2].codec = &g_audio_codec;
 
-  // Create our pipeline.
-  MockPipeline pipeline;
-
-  // Create our data source.
-  MockFilterConfig config;
-  scoped_refptr<MockDataSource> data_source = new MockDataSource(&config);
-  MockFilterHost<DataSource> filter_host_a(&pipeline, data_source);
-  EXPECT_TRUE(data_source->Initialize("foo"));
-  EXPECT_TRUE(filter_host_a.IsInitialized());
-
-  // Create our demuxer.
-  scoped_refptr<FilterFactory> factory = FFmpegDemuxer::CreateFilterFactory();
-  scoped_refptr<Demuxer> demuxer
-      = factory->Create<Demuxer>(data_source->media_format());
-  EXPECT_TRUE(demuxer);
-  MockFilterHost<Demuxer> filter_host_b(&pipeline, demuxer);
-  EXPECT_TRUE(demuxer->Initialize(data_source));
-  EXPECT_TRUE(filter_host_b.WaitForInitialized());
-  EXPECT_TRUE(filter_host_b.IsInitialized());
-  EXPECT_EQ(PIPELINE_OK, pipeline.GetError());
+  // Initialize the demuxer.
+  EXPECT_TRUE(demuxer_->Initialize(data_source_.get()));
+  EXPECT_TRUE(filter_host_->WaitForInitialized());
+  EXPECT_TRUE(filter_host_->IsInitialized());
+  EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
 
   // Since we ignore data streams, the duration should be equal to the video
   // stream's duration.
-  EXPECT_EQ(g_streams[1].duration, pipeline.GetDuration().InMicroseconds());
+  EXPECT_EQ(g_streams[1].duration, pipeline_->GetDuration().InMicroseconds());
 
   // Verify that 2 out of 3 streams were created.
-  EXPECT_EQ(2, demuxer->GetNumberOfStreams());
+  EXPECT_EQ(2, demuxer_->GetNumberOfStreams());
 
   // First stream should be video and support FFmpegDemuxerStream interface.
-  scoped_refptr<DemuxerStream> stream = demuxer->GetStream(0);
+  scoped_refptr<DemuxerStream> stream = demuxer_->GetStream(0);
   scoped_refptr<FFmpegDemuxerStream> ffmpeg_demuxer_stream;
   ASSERT_TRUE(stream);
   std::string mime_type;
   EXPECT_TRUE(
       stream->media_format().GetAsString(MediaFormat::kMimeType, &mime_type));
   EXPECT_STREQ(mime_type::kFFmpegVideo, mime_type.c_str());
   EXPECT_TRUE(stream->QueryInterface(&ffmpeg_demuxer_stream));
   EXPECT_TRUE(ffmpeg_demuxer_stream);
   EXPECT_EQ(&g_streams[1], ffmpeg_demuxer_stream->av_stream());
 
   // Second stream should be audio and support FFmpegDemuxerStream interface.
-  stream = demuxer->GetStream(1);
+  stream = demuxer_->GetStream(1);
   ffmpeg_demuxer_stream = NULL;
   ASSERT_TRUE(stream);
-  EXPECT_TRUE(
-      stream->media_format().GetAsString(MediaFormat::kMimeType, &mime_type));
+  EXPECT_TRUE(stream->media_format().GetAsString(MediaFormat::kMimeType,
+              &mime_type));
   EXPECT_STREQ(mime_type::kFFmpegAudio, mime_type.c_str());
   EXPECT_TRUE(stream->QueryInterface(&ffmpeg_demuxer_stream));
   EXPECT_TRUE(ffmpeg_demuxer_stream);
   EXPECT_EQ(&g_streams[2], ffmpeg_demuxer_stream->av_stream());
 }
 
-// TODO(scherkus): as we keep refactoring and improving our mocks (both FFmpeg
-// and pipeline/filters), try to break this test into two.  Big issue right now
-// is that it takes ~50 lines of code just to set up FFmpegDemuxer.
-//
-// TODO(scherkus): http://crbug.com/10863
-TEST(FFmpegDemuxerTest, DISABLED_ReadAndSeek) {
+TEST_F(FFmpegDemuxerTest, ReadAndSeek) {
   // Prepare some test data.
   const int kPacketData = 0;
   const int kPacketAudio = 1;
   const int kPacketVideo = 2;
   const int kAudio = 0;
   const int kVideo = 1;
   const size_t kDataSize = 4;
   uint8 audio_data[kDataSize] = {0, 1, 2, 3};
   uint8 video_data[kDataSize] = {4, 5, 6, 7};
 
   // Simulate media with a data stream, audio stream and video stream.  Having
   // the data stream first forces the audio and video streams to get remapped
   // from indices {1,2} to {0,1} respectively, which covers an important test
   // case.
-  InitializeFFmpegMocks();
   g_format.nb_streams = 3;
   g_format.streams[kPacketData] = &g_streams[0];
   g_format.streams[kPacketAudio] = &g_streams[1];
   g_format.streams[kPacketVideo] = &g_streams[2];
   g_streams[0].duration = 10;
   g_streams[0].codec = &g_data_codec;
   g_streams[1].duration = 10;
   g_streams[1].codec = &g_audio_codec;
   g_streams[2].duration = 10;
   g_streams[2].codec = &g_video_codec;
 
-  // Create our pipeline.
-  MockPipeline pipeline;
-
-  // Create our data source.
-  MockFilterConfig config;
-  scoped_refptr<MockDataSource> data_source = new MockDataSource(&config);
-  MockFilterHost<DataSource> filter_host_a(&pipeline, data_source);
-  EXPECT_TRUE(data_source->Initialize("foo"));
-  EXPECT_TRUE(filter_host_a.IsInitialized());
-
-  // Create our demuxer.
-  scoped_refptr<FilterFactory> factory = FFmpegDemuxer::CreateFilterFactory();
-  scoped_refptr<Demuxer> demuxer
-      = factory->Create<Demuxer>(data_source->media_format());
-  EXPECT_TRUE(demuxer);
-  MockFilterHost<Demuxer> filter_host_b(&pipeline, demuxer);
-  EXPECT_TRUE(demuxer->Initialize(data_source));
-  EXPECT_TRUE(filter_host_b.WaitForInitialized());
-  EXPECT_TRUE(filter_host_b.IsInitialized());
-  EXPECT_EQ(PIPELINE_OK, pipeline.GetError());
+  // Initialize the demuxer.
+  EXPECT_TRUE(demuxer_->Initialize(data_source_.get()));
+  EXPECT_TRUE(filter_host_->WaitForInitialized());
+  EXPECT_TRUE(filter_host_->IsInitialized());
+  EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
 
   // Verify both streams were created.
-  EXPECT_EQ(2, demuxer->GetNumberOfStreams());
+  EXPECT_EQ(2, demuxer_->GetNumberOfStreams());
 
   // Get our streams.
-  scoped_refptr<DemuxerStream> audio_stream = demuxer->GetStream(kAudio);
-  scoped_refptr<DemuxerStream> video_stream = demuxer->GetStream(kVideo);
+  scoped_refptr<DemuxerStream> audio_stream = demuxer_->GetStream(kAudio);
+  scoped_refptr<DemuxerStream> video_stream = demuxer_->GetStream(kVideo);
   ASSERT_TRUE(audio_stream);
   ASSERT_TRUE(video_stream);
 
   // Prepare data packets, which should all get immediately released.
   PacketQueue::get()->Enqueue(kPacketData, kDataSize, audio_data);
   PacketQueue::get()->Enqueue(kPacketData, kDataSize, audio_data);
   PacketQueue::get()->Enqueue(kPacketData, kDataSize, audio_data);
 
   // Prepare our test audio packet.
   PacketQueue::get()->Enqueue(kPacketAudio, kDataSize, audio_data);
 
   // Attempt a read from the audio stream and run the message loop until done.
   scoped_refptr<TestReader> reader(new TestReader());
   reader->Read(audio_stream);
-  pipeline.RunAllTasks();
+  pipeline_->RunAllTasks();
   EXPECT_TRUE(reader->WaitForRead());
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
   EXPECT_FALSE(reader->buffer()->IsDiscontinuous());
   EXPECT_EQ(audio_data, reader->buffer()->GetData());
   EXPECT_EQ(kDataSize, reader->buffer()->GetDataSize());
 
   // Prepare our test video packet.
   PacketQueue::get()->Enqueue(kPacketVideo, kDataSize, video_data);
 
   // Attempt a read from the video stream and run the message loop until done.
   reader->Reset();
   reader->Read(video_stream);
-  pipeline.RunAllTasks();
+  pipeline_->RunAllTasks();
   EXPECT_TRUE(reader->WaitForRead());
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
   EXPECT_FALSE(reader->buffer()->IsDiscontinuous());
   EXPECT_EQ(video_data, reader->buffer()->GetData());
   EXPECT_EQ(kDataSize, reader->buffer()->GetDataSize());
 
   // Manually release buffer, which should release any remaining AVPackets.
   reader = NULL;
   EXPECT_TRUE(PacketQueue::get()->WaitForOutstandingPackets(0));
 
   //----------------------------------------------------------------------------
   // Seek tests.
   EXPECT_FALSE(g_seek_event);
   g_seek_event = new base::WaitableEvent(false, false);
 
   // Let's trigger a simple forward seek with no outstanding packets.
   g_expected_seek_timestamp = 1234;
   g_expected_seek_flags = 0;
-  demuxer->Seek(base::TimeDelta::FromMicroseconds(g_expected_seek_timestamp));
+  demuxer_->Seek(base::TimeDelta::FromMicroseconds(g_expected_seek_timestamp));
   EXPECT_TRUE(g_seek_event->TimedWait(base::TimeDelta::FromSeconds(1)));
 
   // The next read from each stream should now be discontinuous, but subsequent
   // reads should not.
 
   // Prepare our test audio packet.
   PacketQueue::get()->Enqueue(kPacketAudio, kDataSize, audio_data);
   PacketQueue::get()->Enqueue(kPacketAudio, kDataSize, audio_data);
 
   // Audio read #1, should be discontinuous.
   reader = new TestReader();
   reader->Read(audio_stream);
-  pipeline.RunAllTasks();
+  pipeline_->RunAllTasks();
   EXPECT_TRUE(reader->WaitForRead());
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
   EXPECT_TRUE(reader->buffer()->IsDiscontinuous());
   EXPECT_EQ(audio_data, reader->buffer()->GetData());
   EXPECT_EQ(kDataSize, reader->buffer()->GetDataSize());
 
   // Audio read #2, should not be discontinuous.
   reader->Reset();
   reader->Read(audio_stream);
-  pipeline.RunAllTasks();
+  pipeline_->RunAllTasks();
   EXPECT_TRUE(reader->WaitForRead());
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
   EXPECT_FALSE(reader->buffer()->IsDiscontinuous());
   EXPECT_EQ(audio_data, reader->buffer()->GetData());
   EXPECT_EQ(kDataSize, reader->buffer()->GetDataSize());
 
   // Prepare our test video packet.
   PacketQueue::get()->Enqueue(kPacketVideo, kDataSize, video_data);
   PacketQueue::get()->Enqueue(kPacketVideo, kDataSize, video_data);
 
   // Video read #1, should be discontinuous.
   reader->Reset();
   reader->Read(video_stream);
-  pipeline.RunAllTasks();
+  pipeline_->RunAllTasks();
   EXPECT_TRUE(reader->WaitForRead());
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
   EXPECT_TRUE(reader->buffer()->IsDiscontinuous());
   EXPECT_EQ(video_data, reader->buffer()->GetData());
   EXPECT_EQ(kDataSize, reader->buffer()->GetDataSize());
 
   // Video read #2, should not be discontinuous.
   reader->Reset();
   reader->Read(video_stream);
-  pipeline.RunAllTasks();
+  pipeline_->RunAllTasks();
   EXPECT_TRUE(reader->WaitForRead());
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
   EXPECT_FALSE(reader->buffer()->IsDiscontinuous());
   EXPECT_EQ(video_data, reader->buffer()->GetData());
   EXPECT_EQ(kDataSize, reader->buffer()->GetDataSize());
 
   // Manually release buffer, which should release any remaining AVPackets.
   reader = NULL;
   EXPECT_TRUE(PacketQueue::get()->WaitForOutstandingPackets(0));
 
   // Let's trigger another simple forward seek, but with outstanding packets.
   // The outstanding packets should get freed after the Seek() is issued.
   PacketQueue::get()->Enqueue(kPacketAudio, kDataSize, audio_data);
   PacketQueue::get()->Enqueue(kPacketAudio, kDataSize, audio_data);
   PacketQueue::get()->Enqueue(kPacketAudio, kDataSize, audio_data);
   PacketQueue::get()->Enqueue(kPacketVideo, kDataSize, video_data);
 
   // Attempt a read from video stream, which will force the demuxer to queue
   // the audio packets preceding the video packet.
   reader = new TestReader();
   reader->Read(video_stream);
-  pipeline.RunAllTasks();
+  pipeline_->RunAllTasks();
   EXPECT_TRUE(reader->WaitForRead());
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
   EXPECT_FALSE(reader->buffer()->IsDiscontinuous());
   EXPECT_EQ(video_data, reader->buffer()->GetData());
   EXPECT_EQ(kDataSize, reader->buffer()->GetDataSize());
 
   // Manually release video buffer, remaining audio packets are outstanding.
   reader = NULL;
   EXPECT_TRUE(PacketQueue::get()->WaitForOutstandingPackets(3));
 
   // Trigger the seek.
   g_expected_seek_timestamp = 1234;
   g_expected_seek_flags = 0;
-  demuxer->Seek(base::TimeDelta::FromMicroseconds(g_expected_seek_timestamp));
+  demuxer_->Seek(base::TimeDelta::FromMicroseconds(g_expected_seek_timestamp));
   EXPECT_TRUE(g_seek_event->TimedWait(base::TimeDelta::FromSeconds(1)));
 
   // All outstanding packets should have been freed.
   EXPECT_TRUE(PacketQueue::get()->WaitForOutstandingPackets(0));
 
   // Clean up.
   delete g_seek_event;
   g_seek_event = NULL;
 
   //----------------------------------------------------------------------------
   // End of stream tests.
 
   // Simulate end of stream.
   g_av_read_frame = AVERROR_IO;
 
   // Attempt a read from the audio stream and run the message loop until done.
   reader = new TestReader();
   reader->Read(audio_stream);
-  pipeline.RunAllTasks();
+  pipeline_->RunAllTasks();
   EXPECT_FALSE(reader->WaitForRead());
   EXPECT_FALSE(reader->called());
   EXPECT_FALSE(reader->buffer());
 
   // Manually release buffer, which should release any remaining AVPackets.
   reader = NULL;
   EXPECT_TRUE(PacketQueue::get()->WaitForOutstandingPackets(0));
 }