media-internals: Remove audio/video codec reporting from mp4 parser

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 "media/formats/mp4/mp4_stream_parser.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 22 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::InSequence;
 using ::testing::StrictMock;
 using base::TimeDelta;
 
 namespace media {
 namespace mp4 {
 
 // Matchers for verifying common media log entry strings.
-MATCHER_P(VideoCodecLog, codec_string, "") {
-  return CONTAINS_STRING(arg, "Video codec: " + std::string(codec_string));
-}
-
-MATCHER_P(AudioCodecLog, codec_string, "") {
-  return CONTAINS_STRING(arg, "Audio codec: " + std::string(codec_string));
-}
-
 MATCHER(SampleEncryptionInfoUnavailableLog, "") {
   return CONTAINS_STRING(arg, "Sample encryption info is not available.");
 }
 
 MATCHER_P(ErrorLog, error_string, "") {
   return CONTAINS_STRING(arg, error_string);
 }
 
 class MP4StreamParserTest : public testing::Test {
  public:
@@ skipping 169 matching lines @@
     EXPECT_TRUE(AppendDataInPieces(buffer->data(),
                                    buffer->data_size(),
                                    append_bytes));
     return true;
   }
 };
 
 TEST_F(MP4StreamParserTest, UnalignedAppend) {
   // Test small, non-segment-aligned appends (small enough to exercise
   // incremental append system)
-  EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
-  EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
   InitializeParser();
   ParseMP4File("bear-1280x720-av_frag.mp4", 512);
 }
 
 TEST_F(MP4StreamParserTest, BytewiseAppend) {
   // Ensure no incremental errors occur when parsing
-  EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
-  EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
   InitializeParser();
   ParseMP4File("bear-1280x720-av_frag.mp4", 1);
 }
 
 TEST_F(MP4StreamParserTest, MultiFragmentAppend) {
   // Large size ensures multiple fragments are appended in one call (size is
   // larger than this particular test file)
-  EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
-  EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
   InitializeParser();
   ParseMP4File("bear-1280x720-av_frag.mp4", 768432);
 }
 
 TEST_F(MP4StreamParserTest, Flush) {
   // Flush while reading sample data, then start a new stream.
-  EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F")).Times(2);
-  EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2")).Times(2);
   InitializeParser();
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-1280x720-av_frag.mp4");
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), 65536, 512));
   parser_->Flush();
   EXPECT_TRUE(AppendDataInPieces(buffer->data(),
                                  buffer->data_size(),
                                  512));
 }
 
 TEST_F(MP4StreamParserTest, Reinitialization) {
-  EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F")).Times(2);
-  EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2")).Times(2);
   InitializeParser();
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-1280x720-av_frag.mp4");
   EXPECT_TRUE(AppendDataInPieces(buffer->data(),
                                  buffer->data_size(),
                                  512));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(),
                                  buffer->data_size(),
                                  512));
 }
 
 TEST_F(MP4StreamParserTest, UnknownDuration_V0_AllBitsSet) {
-  EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
-  EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
   InitializeParser();
   // 32 bit duration field in mvhd box, all bits set.
   ParseMP4File(
       "bear-1280x720-av_frag-initsegment-mvhd_version_0-mvhd_duration_bits_all_"
       "set.mp4",
       512);
 }
 
 TEST_F(MP4StreamParserTest, MPEG2_AAC_LC) {
   InSequence s;
   std::set<int> audio_object_types;
   audio_object_types.insert(kISO_13818_7_AAC_LC);
   parser_.reset(new MP4StreamParser(audio_object_types, false));
-  EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.67"));
-  EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
   auto params = GetDefaultInitParametersExpectations();
   params.detected_video_track_count = 0;
   InitializeParserWithInitParametersExpectations(params);
   ParseMP4File("bear-mpeg2-aac-only_frag.mp4", 512);
 }
 
 // Test that a moov box is not always required after Flush() is called.
 TEST_F(MP4StreamParserTest, NoMoovAfterFlush) {
-  EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
-  EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
   InitializeParser();
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-1280x720-av_frag.mp4");
   EXPECT_TRUE(AppendDataInPieces(buffer->data(),
                                  buffer->data_size(),
                                  512));
   parser_->Flush();
 
   const int kFirstMoofOffset = 1307;
@@ skipping 12 matching lines @@
   // Encrypted test mp4 files have non-zero duration and are treated as
   // recorded streams.
   auto params = GetDefaultInitParametersExpectations();
   params.duration = base::TimeDelta::FromMicroseconds(23219);
   params.liveness = DemuxerStream::LIVENESS_RECORDED;
   params.detected_video_track_count = 0;
   InitializeParserWithInitParametersExpectations(params);
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-1280x720-a_frag-cenc_missing-saiz-saio.mp4");
-  EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2")).Times(2);
   EXPECT_MEDIA_LOG(SampleEncryptionInfoUnavailableLog());
   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"));
   auto params = GetDefaultInitParametersExpectations();
   params.detected_audio_track_count = 0;
   InitializeParserWithInitParametersExpectations(params);
   ParseMP4File("bear-1280x720-av_with-aud-nalus_frag.mp4", 512);
 }
 
 TEST_F(MP4StreamParserTest, HEVC_in_MP4_container) {
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   bool expect_success = true;
-  EXPECT_MEDIA_LOG(VideoCodecLog("hevc"));
 #else
   bool expect_success = false;
   EXPECT_MEDIA_LOG(ErrorLog("Parse unsupported video format hev1"));
 #endif
   auto params = GetDefaultInitParametersExpectations();
   params.duration = base::TimeDelta::FromMicroseconds(1002000);
   params.liveness = DemuxerStream::LIVENESS_RECORDED;
   params.detected_audio_track_count = 0;
   InitializeParserWithInitParametersExpectations(params);
 
@@ skipping 12 matching lines @@
   // Encrypted test mp4 files have non-zero duration and are treated as
   // recorded streams.
   auto params = GetDefaultInitParametersExpectations();
   params.duration = base::TimeDelta::FromMicroseconds(2736066);
   params.liveness = DemuxerStream::LIVENESS_RECORDED;
   params.detected_audio_track_count = 0;
   InitializeParserWithInitParametersExpectations(params);
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-1280x720-v_frag-cenc.mp4");
-  EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
 
 TEST_F(MP4StreamParserTest, CencWithSampleEncryptionBox) {
   // Encrypted test mp4 files have non-zero duration and are treated as
   // recorded streams.
   auto params = GetDefaultInitParametersExpectations();
   params.duration = base::TimeDelta::FromMicroseconds(2736066);
   params.liveness = DemuxerStream::LIVENESS_RECORDED;
   params.detected_audio_track_count = 0;
   InitializeParserWithInitParametersExpectations(params);
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-640x360-v_frag-cenc-senc.mp4");
-  EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001E"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
 
 TEST_F(MP4StreamParserTest, NaturalSizeWithoutPASP) {
   auto params = GetDefaultInitParametersExpectations();
   params.duration = base::TimeDelta::FromMicroseconds(1000966);
   params.liveness = DemuxerStream::LIVENESS_RECORDED;
   params.detected_audio_track_count = 0;
   InitializeParserWithInitParametersExpectations(params);
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-640x360-non_square_pixel-without_pasp.mp4");
 
-  EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001E"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
   EXPECT_EQ(gfx::Size(639, 360), video_decoder_config_.natural_size());
 }
 
 TEST_F(MP4StreamParserTest, NaturalSizeWithPASP) {
   auto params = GetDefaultInitParametersExpectations();
   params.duration = base::TimeDelta::FromMicroseconds(1000966);
   params.liveness = DemuxerStream::LIVENESS_RECORDED;
   params.detected_audio_track_count = 0;
   InitializeParserWithInitParametersExpectations(params);
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-640x360-non_square_pixel-with_pasp.mp4");
 
-  EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001E"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
   EXPECT_EQ(gfx::Size(639, 360), video_decoder_config_.natural_size());
 }
 
 TEST_F(MP4StreamParserTest, DemuxingAC3) {
   std::set<int> audio_object_types;
   audio_object_types.insert(kAC3);
   parser_.reset(new MP4StreamParser(audio_object_types, false));
 
 #if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
@@ skipping 44 matching lines @@
   EXPECT_EQ("mvex", FourCCToString(FOURCC_MVEX));
 
   // Invalid FOURCC should also print whenever ASCII values are printable.
   EXPECT_EQ("fake", FourCCToString(static_cast<FourCC>(0x66616b65)));
 
   // Invalid FORCC with non-printable values should not give error message.
   EXPECT_EQ("0x66616b00", FourCCToString(static_cast<FourCC>(0x66616b00)));
 }
 
 TEST_F(MP4StreamParserTest, MediaTrackInfoSourcing) {
-  EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
-  EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
   InitializeParser();
   ParseMP4File("bear-1280x720-av_frag.mp4", 4096);
 
   EXPECT_EQ(media_tracks_->tracks().size(), 2u);
   const MediaTrack& video_track = *(media_tracks_->tracks()[0]);
   EXPECT_EQ(video_track.type(), MediaTrack::Video);
   EXPECT_EQ(video_track.bytestream_track_id(), 1);
   EXPECT_EQ(video_track.kind(), "main");
   EXPECT_EQ(video_track.label(), "VideoHandler");
   EXPECT_EQ(video_track.language(), "und");
 
   const MediaTrack& audio_track = *(media_tracks_->tracks()[1]);
   EXPECT_EQ(audio_track.type(), MediaTrack::Audio);
   EXPECT_EQ(audio_track.bytestream_track_id(), 2);
   EXPECT_EQ(audio_track.kind(), "main");
   EXPECT_EQ(audio_track.label(), "SoundHandler");
   EXPECT_EQ(audio_track.language(), "und");
 }
 
 TEST_F(MP4StreamParserTest, TextTrackDetection) {
   auto params = GetDefaultInitParametersExpectations();
   params.detected_text_track_count = 1;
   InitializeParserWithInitParametersExpectations(params);
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-1280x720-avt_subt_frag.mp4");
 
-  EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
-  EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
 
 TEST_F(MP4StreamParserTest, MultiTrackFile) {
   auto params = GetDefaultInitParametersExpectations();
   params.duration = base::TimeDelta::FromMilliseconds(4248);
   params.liveness = DemuxerStream::LIVENESS_RECORDED;
   params.detected_audio_track_count = 2;
   params.detected_video_track_count = 2;
   InitializeParserWithInitParametersExpectations(params);
-  EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64000D")).Times(2);
-  EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2")).Times(2);
   ParseMP4File("bbb-320x240-2video-2audio.mp4", 4096);
 
   EXPECT_EQ(media_tracks_->tracks().size(), 4u);
 
   const MediaTrack& video_track1 = *(media_tracks_->tracks()[0]);
   EXPECT_EQ(video_track1.type(), MediaTrack::Video);
   EXPECT_EQ(video_track1.bytestream_track_id(), 1);
   EXPECT_EQ(video_track1.kind(), "main");
   EXPECT_EQ(video_track1.label(), "VideoHandler");
   EXPECT_EQ(video_track1.language(), "und");
@@ skipping 15 matching lines @@
   const MediaTrack& audio_track2 = *(media_tracks_->tracks()[3]);
   EXPECT_EQ(audio_track2.type(), MediaTrack::Audio);
   EXPECT_EQ(audio_track2.bytestream_track_id(), 4);
   EXPECT_EQ(audio_track2.kind(), "");
   EXPECT_EQ(audio_track2.label(), "SoundHandler");
   EXPECT_EQ(audio_track2.language(), "und");
 }
 
 }  // namespace mp4
 }  // namespace media