Run ac3, eac3 and hevc unit tests in all configs

media/formats/mp4/mp4_stream_parser_unittest.cc

 // Copyright 2014 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 <string>
 
@@ skipping 28 matching lines @@
 }
 
 MATCHER_P(AudioCodecLog, codec_string, "") {
   return CONTAINS_STRING(arg, "Audio codec: " + std::string(codec_string));
 }
 
 MATCHER(AuxInfoUnavailableLog, "") {
   return CONTAINS_STRING(arg, "Aux Info is not available.");
 }
 
+MATCHER_P(ErrorLog, error_string, "") {
+  return CONTAINS_STRING(arg, error_string);
+}
+
 class MP4StreamParserTest : public testing::Test {
  public:
   MP4StreamParserTest()
       : media_log_(new StrictMock<MockMediaLog>()),
         configs_received_(false),
         lower_bound_(
             DecodeTimestamp::FromPresentationTime(base::TimeDelta::Max())) {
     std::set<int> audio_object_types;
     audio_object_types.insert(kISO_14496_3);
     parser_.reset(new MP4StreamParser(audio_object_types, false));
@@ skipping 234 matching lines @@
   EXPECT_FALSE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
 
 // Test a file where all video samples start with an Access Unit
 // Delimiter (AUD) NALU.
 TEST_F(MP4StreamParserTest, VideoSamplesStartWithAUDs) {
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.4d4028"));
   ParseMP4File("bear-1280x720-av_with-aud-nalus_frag.mp4", 512);
 }
 
+TEST_F(MP4StreamParserTest, HEVC_in_MP4_container) {
+  bool expect_success = true;

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

nit: Might be better for symmetry to put this inside the if. Also, the default
(most common) is really false.

This is consistent with the others below, but those also use the inverse logic,
so I'm not sure how much that matters. Anyway, up to you.

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

Done (fixed also the inverse logic below for consistency).

 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-TEST_F(MP4StreamParserTest, HEVC_in_MP4_container) {
+  EXPECT_MEDIA_LOG(VideoCodecLog("hevc"));

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

Is there a reason we don't have these for the audio codecs below?

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

In case of HEVC we do some trivial parsing of the bit stream (we parse the hvcC
box in the mp4 file, that contains the HEVCDecoderConfigurationRecord structure,
since we want to know the video size/resolution), and after that parsing is
finished successfully the VideoCodec message is logged. In case of AC3/EAC3
audio we support only pass-through, we don't need to know any parameters of the
input streams, so we just demux those and never even try to parse them, so no
AudioCodec is logged to the MSE media log. We do have audio codec logging in
lower level of Chromecast media stack, so it doesn't matter, but if you prefer,
I can also add AudioCodec log message for AC3/EAC3.

+#else
+  expect_success = false;
+  EXPECT_MEDIA_LOG(ErrorLog("Parse unsupported video format hev1"));
+#endif
   InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_RECORDED);
   scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("bear-hevc-frag.mp4");
-  EXPECT_MEDIA_LOG(VideoCodecLog("hevc"));
-  EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
+  EXPECT_EQ(expect_success,
+            AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
-#endif
 
 TEST_F(MP4StreamParserTest, CENC) {
   // Encrypted test mp4 files have non-zero duration and are treated as
   // recorded streams.
   InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_RECORDED);
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-1280x720-v_frag-cenc.mp4");
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.6401f"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
@@ skipping 14 matching lines @@
   InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_RECORDED);
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-640x360-non_square_pixel-with_pasp.mp4");
 
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.6401e"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
   EXPECT_EQ(gfx::Size(639, 360), video_decoder_config_.natural_size());
 }
 
-#if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
 TEST_F(MP4StreamParserTest, DemuxingAC3) {
   std::set<int> audio_object_types;
   audio_object_types.insert(kAC3);
   parser_.reset(new MP4StreamParser(audio_object_types, false));
+
+  bool expect_success = true;
+#if !BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
+  expect_success = false;
+  EXPECT_MEDIA_LOG(ErrorLog("Unsupported audio format 0x61632d33 in stsd box"));
+#endif
+
   InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_RECORDED);
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-ac3-only-frag.mp4");
-  EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
+  EXPECT_EQ(expect_success,
+            AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
 
 TEST_F(MP4StreamParserTest, DemuxingEAC3) {
   std::set<int> audio_object_types;
   audio_object_types.insert(kEAC3);
   parser_.reset(new MP4StreamParser(audio_object_types, false));
+
+  bool expect_success = true;
+#if !BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
+  expect_success = false;
+  EXPECT_MEDIA_LOG(ErrorLog("Unsupported audio format 0x65632d33 in stsd box"));
+#endif
+
   InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_RECORDED);
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-eac3-only-frag.mp4");
-  EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
+  EXPECT_EQ(expect_success,
+            AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
-#endif
 
 }  // namespace mp4
 }  // namespace media