Run ac3, eac3 and hevc unit tests in all configs

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <deque>
 #include <string>
@@ skipping 82 matching lines @@
 
     demuxer_.reset(new FFmpegDemuxer(
         message_loop_.task_runner(), data_source_.get(),
         encrypted_media_init_data_cb, new MediaLog()));
   }
 
   MOCK_METHOD1(CheckPoint, void(int v));
 
   void InitializeDemuxerWithTimelineOffset(bool enable_text,
                                            base::Time timeline_offset) {
-    EXPECT_CALL(host_, SetDuration(_));
+    if (demuxer_init_expected_status_ == PIPELINE_OK)

[ddorwin, 2016/01/23 00:38:56]

This doesn't really need to be a member.

Add InitializeDemuxerExpectUnsupportedFormat() or something like that to pass
DEMUXER_ERROR_NO_SUPPORTED_STREAMS to this function as |expected_status|. Since
we have two calls anyway (in the #if and #else), this will be clearer

[servolk, 2016/02/10 18:58:50]

Done.

+      EXPECT_CALL(host_, SetDuration(_));
     WaitableMessageLoopEvent event;
     demuxer_->Initialize(&host_, event.GetPipelineStatusCB(), enable_text);
     demuxer_->timeline_offset_ = timeline_offset;
-    event.RunAndWaitForStatus(PIPELINE_OK);
+    event.RunAndWaitForStatus(demuxer_init_expected_status_);
   }
 
   void InitializeDemuxerText(bool enable_text) {

[ddorwin, 2016/01/23 00:38:56]

Unrelated except that it may avoid adding an |expected_status| parameter here:

Calling this from InitializeDemuxer() seems overly complex. This should probably
just be called InitializeDemuxerWithText() then InitializeDemuxer should call
the function below directly. That also avoids unclear |true| parameters at the
call site.

WDYT?

[servolk, 2016/02/10 18:58:50]

Yeah, I think it would be cleaner if we just had a single InitializeDemuxer
method with 3 parameters, and then we can use default arguments to keep usage
simple for most common cases.

     InitializeDemuxerWithTimelineOffset(enable_text, base::Time());
   }
 
   void InitializeDemuxer() {
     InitializeDemuxerText(false);
   }
 
   MOCK_METHOD2(OnReadDoneCalled, void(int, int64_t));
 
   struct ReadExpectation {
@@ skipping 77 matching lines @@
 
   bool IsStreamStopped(DemuxerStream::Type type) {
     DemuxerStream* stream = demuxer_->GetStream(type);
     CHECK(stream);
     return !static_cast<FFmpegDemuxerStream*>(stream)->demuxer_;
   }
 
   // Fixture members.
   scoped_ptr<FileDataSource> data_source_;
   scoped_ptr<FFmpegDemuxer> demuxer_;
+  media::PipelineStatus demuxer_init_expected_status_ = PIPELINE_OK;
   StrictMock<MockDemuxerHost> host_;
   base::MessageLoop message_loop_;
 
   AVFormatContext* format_context() {
     return demuxer_->glue_->format_context();
   }
 
   int preferred_seeking_stream_index() const {
     return demuxer_->preferred_stream_for_seeking_.first;
   }
@@ skipping 892 matching lines @@
 
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(stream);
 
   const VideoDecoderConfig& video_config = stream->video_decoder_config();
   EXPECT_EQ(gfx::Size(639, 360), video_config.natural_size());
 }
 
 #endif
 
-#if BUILDFLAG(ENABLE_HEVC_DEMUXING)
 TEST_F(FFmpegDemuxerTest, HEVC_in_MP4_container) {
   CreateDemuxer("bear-hevc-frag.mp4");
+#if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   InitializeDemuxer();
 
   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(video);
 
   video->Read(NewReadCB(FROM_HERE, 3569, 66733, true));
   message_loop_.Run();
 
   video->Read(NewReadCB(FROM_HERE, 1042, 200200, false));
   message_loop_.Run();
+#else
+  demuxer_init_expected_status_ = DEMUXER_ERROR_NO_SUPPORTED_STREAMS;
+  InitializeDemuxer();
+#endif
 }
-#endif
 
-#if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
 TEST_F(FFmpegDemuxerTest, Read_AC3_Audio) {
   CreateDemuxer("bear-ac3-only-frag.mp4");
+#if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
   InitializeDemuxer();
 
   // Attempt a read from the audio stream and run the message loop until done.
   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 
   // Read the first two frames and check that we are getting expected data
   audio->Read(NewReadCB(FROM_HERE, 834, 0, true));
   message_loop_.Run();
 
   audio->Read(NewReadCB(FROM_HERE, 836, 34830, true));
   message_loop_.Run();
+#else
+  demuxer_init_expected_status_ = DEMUXER_ERROR_NO_SUPPORTED_STREAMS;
+  InitializeDemuxer();
+#endif
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EAC3_Audio) {
   CreateDemuxer("bear-eac3-only-frag.mp4");
+#if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
   InitializeDemuxer();
 
   // Attempt a read from the audio stream and run the message loop until done.
   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 
   // Read the first two frames and check that we are getting expected data
   audio->Read(NewReadCB(FROM_HERE, 870, 0, true));
   message_loop_.Run();
 
   audio->Read(NewReadCB(FROM_HERE, 872, 34830, true));
   message_loop_.Run();
+#else
+  demuxer_init_expected_status_ = DEMUXER_ERROR_NO_SUPPORTED_STREAMS;
+  InitializeDemuxer();
+#endif
 }
-#endif  // ENABLE_AC3_EAC3_AUDIO_DEMUXING
 
 }  // namespace media