MSE: Verify MediaLog events created by existing MP4 unit tests

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 <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
+#include "media/base/mock_media_log.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/test_data_util.h"
 #include "media/base/text_track_config.h"
 #include "media/base/video_decoder_config.h"
 #include "media/formats/mp4/es_descriptor.h"
 #include "media/formats/mp4/mp4_stream_parser.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #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.
+#define CONTAINS_STRING(arg, x) (std::string::npos != (arg).find(x))
+
+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(AuxInfoUnavailableLog, "") {
+  return CONTAINS_STRING(arg, "Aux Info is not available.");
+}
+
 class MP4StreamParserTest : public testing::Test {
  public:
   MP4StreamParserTest()
-      : configs_received_(false),
+      : 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));
   }
 
  protected:
+  scoped_refptr<StrictMock<MockMediaLog>> media_log_;
   scoped_ptr<MP4StreamParser> parser_;
   bool configs_received_;
   AudioDecoderConfig audio_decoder_config_;
   VideoDecoderConfig video_decoder_config_;
   DecodeTimestamp lower_bound_;
 
   bool AppendData(const uint8* data, size_t length) {
     return parser_->Parse(data, length);
   }
 
@@ skipping 92 matching lines @@
       DemuxerStream::Liveness expected_liveness) {
     parser_->Init(
         base::Bind(&MP4StreamParserTest::InitF, base::Unretained(this),
                    expected_liveness),
         base::Bind(&MP4StreamParserTest::NewConfigF, base::Unretained(this)),
         base::Bind(&MP4StreamParserTest::NewBuffersF, base::Unretained(this)),
         true,
         base::Bind(&MP4StreamParserTest::KeyNeededF, base::Unretained(this)),
         base::Bind(&MP4StreamParserTest::NewSegmentF, base::Unretained(this)),
         base::Bind(&MP4StreamParserTest::EndOfSegmentF, base::Unretained(this)),
-        new MediaLog());
+        media_log_);
   }
 
   void InitializeParser() {
     // Most unencrypted test mp4 files have zero duration and are treated as
     // live streams.
     InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_LIVE);
   }
 
   bool ParseMP4File(const std::string& filename, int append_bytes) {
     InitializeParser();
 
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
     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_STRING(VideoCodecLog("avc1.6401f"));
+  EXPECT_MEDIA_LOG_STRING(AudioCodecLog("mp4a.40.2"));
   ParseMP4File("bear-1280x720-av_frag.mp4", 512);
 }
 
 TEST_F(MP4StreamParserTest, BytewiseAppend) {
   // Ensure no incremental errors occur when parsing
+  EXPECT_MEDIA_LOG_STRING(VideoCodecLog("avc1.6401f"));
+  EXPECT_MEDIA_LOG_STRING(AudioCodecLog("mp4a.40.2"));
   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_STRING(VideoCodecLog("avc1.6401f"));
+  EXPECT_MEDIA_LOG_STRING(AudioCodecLog("mp4a.40.2"));
   ParseMP4File("bear-1280x720-av_frag.mp4", 768432);
 }
 
 TEST_F(MP4StreamParserTest, Flush) {
   // Flush while reading sample data, then start a new stream.
+  EXPECT_MEDIA_LOG_STRING(VideoCodecLog("avc1.6401f")).Times(2);
+  EXPECT_MEDIA_LOG_STRING(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_STRING(VideoCodecLog("avc1.6401f")).Times(2);
+  EXPECT_MEDIA_LOG_STRING(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, MPEG2_AAC_LC) {
+  InSequence s;

[chcunningham, 2015/08/19 19:36:18]

Do you need this? Ditto for line 279.

[chcunningham, 2015/08/19 20:06:43]

ignore... I read up on InSequence. Kinda whacky, but I get it

[wolenetz, 2015/08/24 20:13:52]

Acknowledged.

   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_STRING(AudioCodecLog("mp4a.67"));
+  EXPECT_MEDIA_LOG_STRING(AudioCodecLog("mp4a.40.2"));
   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_STRING(VideoCodecLog("avc1.6401f"));
+  EXPECT_MEDIA_LOG_STRING(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;
   EXPECT_TRUE(AppendDataInPieces(buffer->data() + kFirstMoofOffset,
                                  buffer->data_size() - kFirstMoofOffset,
                                  512));
 }
 
 // Test an invalid file where there are encrypted samples, but
 // SampleAuxiliaryInformation{Sizes|Offsets}Box (saiz|saio) are missing.
 // The parser should fail instead of crash. See http://crbug.com/361347
 TEST_F(MP4StreamParserTest, MissingSampleAuxInfo) {
+  InSequence s;
+
   // 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-a_frag-cenc_missing-saiz-saio.mp4");
+  EXPECT_MEDIA_LOG_STRING(AudioCodecLog("mp4a.40.2")).Times(2);
+  EXPECT_MEDIA_LOG_STRING(AuxInfoUnavailableLog());
   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_STRING(VideoCodecLog("avc1.4d4028"));
   ParseMP4File("bear-1280x720-av_with-aud-nalus_frag.mp4", 512);
 }
 
 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_STRING(VideoCodecLog("avc1.6401f"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
 
 TEST_F(MP4StreamParserTest, NaturalSizeWithoutPASP) {
   InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_RECORDED);
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-640x360-non_square_pixel-without_pasp.mp4");
 
+  EXPECT_MEDIA_LOG_STRING(VideoCodecLog("avc1.6401e"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
   EXPECT_EQ(gfx::Size(638, 360), video_decoder_config_.natural_size());
 }
 
 TEST_F(MP4StreamParserTest, NaturalSizeWithPASP) {
   InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_RECORDED);
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-640x360-non_square_pixel-with_pasp.mp4");
 
+  EXPECT_MEDIA_LOG_STRING(VideoCodecLog("avc1.6401e"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
   EXPECT_EQ(gfx::Size(638, 360), video_decoder_config_.natural_size());
 }
 
 }  // namespace mp4
 }  // namespace media