Convert MediaLog from being ref counted to owned by WebMediaPlayer.

media/formats/mp4/track_run_iterator_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/track_run_iterator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 132 matching lines @@
 
 namespace media {
 namespace mp4 {
 
 MATCHER(ReservedValueInSampleDependencyInfo, "") {
   return CONTAINS_STRING(arg, "Reserved value used in sample dependency info.");
 }
 
 class TrackRunIteratorTest : public testing::Test {
  public:
-  TrackRunIteratorTest() : media_log_(new StrictMock<MockMediaLog>()) {
-    CreateMovie();
-  }
+  TrackRunIteratorTest() { CreateMovie(); }
 
  protected:
+  StrictMock<MockMediaLog> media_log_;
   Movie moov_;
-  scoped_refptr<StrictMock<MockMediaLog>> media_log_;
   std::unique_ptr<TrackRunIterator> iter_;
 
   void CreateMovie() {
     moov_.header.timescale = 1000;
     moov_.tracks.resize(3);
     moov_.extends.tracks.resize(2);
     moov_.tracks[0].header.track_id = 1;
     moov_.tracks[0].media.header.timescale = kAudioScale;
     SampleDescription& desc1 =
         moov_.tracks[0].media.information.sample_table.description;
@@ skipping 309 matching lines @@
   }
 
   void SetAscending(std::vector<uint32_t>* vec) {
     vec->resize(10);
     for (size_t i = 0; i < vec->size(); i++)
       (*vec)[i] = i+1;
   }
 };
 
 TEST_F(TrackRunIteratorTest, NoRunsTest) {
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
   ASSERT_TRUE(iter_->Init(MovieFragment()));
   EXPECT_FALSE(iter_->IsRunValid());
   EXPECT_FALSE(iter_->IsSampleValid());
 }
 
 TEST_F(TrackRunIteratorTest, BasicOperationTest) {
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
   MovieFragment moof = CreateFragment();
 
   // Test that runs are sorted correctly, and that properties of the initial
   // sample of the first run are correct
   ASSERT_TRUE(iter_->Init(moof));
   EXPECT_TRUE(iter_->IsRunValid());
   EXPECT_FALSE(iter_->is_encrypted());
   EXPECT_EQ(iter_->track_id(), 1u);
   EXPECT_EQ(iter_->sample_offset(), 100);
   EXPECT_EQ(iter_->sample_size(), 1);
@@ skipping 36 matching lines @@
             moof.tracks[0].header.default_sample_size,
             iter_->sample_offset());
   iter_->AdvanceRun();
   EXPECT_FALSE(iter_->IsRunValid());
 }
 
 TEST_F(TrackRunIteratorTest, TrackExtendsDefaultsTest) {
   moov_.extends.tracks[0].default_sample_duration = 50;
   moov_.extends.tracks[0].default_sample_size = 3;
   moov_.extends.tracks[0].default_sample_flags = ToSampleFlags("UN");
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
   MovieFragment moof = CreateFragment();
   moof.tracks[0].header.has_default_sample_flags = false;
   moof.tracks[0].header.default_sample_size = 0;
   moof.tracks[0].header.default_sample_duration = 0;
   moof.tracks[0].runs[0].sample_sizes.clear();
   ASSERT_TRUE(iter_->Init(moof));
   iter_->AdvanceSample();
   EXPECT_FALSE(iter_->is_keyframe());
   EXPECT_EQ(iter_->sample_size(), 3);
   EXPECT_EQ(iter_->sample_offset(), moof.tracks[0].runs[0].data_offset + 3);
   EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(50, kAudioScale));
   EXPECT_EQ(iter_->dts(), DecodeTimestampFromRational(50, kAudioScale));
 }
 
 TEST_F(TrackRunIteratorTest, FirstSampleFlagTest) {
   // Ensure that keyframes are flagged correctly in the face of BMFF boxes which
   // explicitly specify the flags for the first sample in a run and rely on
   // defaults for all subsequent samples
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
   MovieFragment moof = CreateFragment();
   moof.tracks[1].header.has_default_sample_flags = true;
   moof.tracks[1].header.default_sample_flags = ToSampleFlags("UN");
   SetFlagsOnSamples("US", &moof.tracks[1].runs[0]);
 
   ASSERT_TRUE(iter_->Init(moof));
   EXPECT_EQ("1 K K K K K K K K K K", KeyframeAndRAPInfo(iter_.get()));
 
   iter_->AdvanceRun();
   EXPECT_EQ("2 K P P P P P P P P P", KeyframeAndRAPInfo(iter_.get()));
 }
 
 // Verify that parsing fails if a reserved value is in the sample flags.
 TEST_F(TrackRunIteratorTest, SampleInfoTest_ReservedInSampleFlags) {
   EXPECT_MEDIA_LOG(ReservedValueInSampleDependencyInfo());
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
   MovieFragment moof = CreateFragment();
   // Change the "depends on" field on one of the samples to a
   // reserved value.
   moof.tracks[1].runs[0].sample_flags[0] = ToSampleFlags("RS");
   ASSERT_FALSE(iter_->Init(moof));
 }
 
 // Verify that parsing fails if a reserved value is in the default sample flags.
 TEST_F(TrackRunIteratorTest, SampleInfoTest_ReservedInDefaultSampleFlags) {
   EXPECT_MEDIA_LOG(ReservedValueInSampleDependencyInfo());
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
   MovieFragment moof = CreateFragment();
   // Set the default flag to contain a reserved "depends on" value.
   moof.tracks[0].header.default_sample_flags = ToSampleFlags("RN");
   ASSERT_FALSE(iter_->Init(moof));
 }
 
 TEST_F(TrackRunIteratorTest, ReorderingTest) {
   // Test frame reordering and edit list support. The frames have the following
   // decode timestamps:
   //
   //   0ms 40ms   120ms     240ms
   //   | 0 | 1  - | 2  -  - |
   //
   // ...and these composition timestamps, after edit list adjustment:
   //
   //   0ms 40ms       160ms  240ms
   //   | 0 | 2  -  -  | 1 - |
 
   // Create an edit list with one entry, with an initial start time of 80ms
   // (that is, 2 / kVideoTimescale) and a duration of zero (which is treated as
   // infinite according to 14496-12:2012). This will cause the first 80ms of the
   // media timeline - which will be empty, due to CTS biasing - to be discarded.
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
   EditListEntry entry;
   entry.segment_duration = 0;
   entry.media_time = 2;
   entry.media_rate_integer = 1;
   entry.media_rate_fraction = 0;
   moov_.tracks[1].edit.list.edits.push_back(entry);
 
   // Add CTS offsets. Without bias, the CTS offsets for the first three frames
   // would simply be [0, 3, -2]. Since CTS offsets should be non-negative for
   // maximum compatibility, these values are biased up to [2, 5, 0], and the
@@ skipping 16 matching lines @@
   EXPECT_EQ(iter_->dts(), DecodeTimestampFromRational(1, kVideoScale));
   EXPECT_EQ(iter_->cts(), TimeDeltaFromRational(4, kVideoScale));
   EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(2, kVideoScale));
   iter_->AdvanceSample();
   EXPECT_EQ(iter_->dts(), DecodeTimestampFromRational(3, kVideoScale));
   EXPECT_EQ(iter_->cts(), TimeDeltaFromRational(1, kVideoScale));
   EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(3, kVideoScale));
 }
 
 TEST_F(TrackRunIteratorTest, IgnoreUnknownAuxInfoTest) {
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
   MovieFragment moof = CreateFragment();
   moof.tracks[1].auxiliary_offset.offsets.push_back(50);
   moof.tracks[1].auxiliary_size.default_sample_info_size = 2;
   moof.tracks[1].auxiliary_size.sample_count = 2;
   moof.tracks[1].runs[0].sample_count = 2;
   ASSERT_TRUE(iter_->Init(moof));
   iter_->AdvanceRun();
   EXPECT_FALSE(iter_->AuxInfoNeedsToBeCached());
 }
 
 TEST_F(TrackRunIteratorTest,
        DecryptConfigTestWithSampleEncryptionAndNoSubsample) {
   AddEncryption(&moov_.tracks[1]);
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
 
   MovieFragment moof = CreateFragment();
   AddSampleEncryption(!SampleEncryption::kUseSubsampleEncryption,
                       &moof.tracks[1]);
 
   ASSERT_TRUE(iter_->Init(moof));
   // The run for track 2 will be the second, which is parsed according to
   // data_offset.
   iter_->AdvanceRun();
   EXPECT_EQ(iter_->track_id(), 2u);
@@ skipping 14 matching lines @@
   iter_->AdvanceSample();
   config = iter_->GetDecryptConfig();
   EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv2), arraysize(kIv2)),
             config->iv());
   EXPECT_EQ(config->subsamples().size(), 0u);
 }
 
 TEST_F(TrackRunIteratorTest,
        DecryptConfigTestWithSampleEncryptionAndSubsample) {
   AddEncryption(&moov_.tracks[1]);
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
 
   MovieFragment moof = CreateFragment();
   AddSampleEncryption(SampleEncryption::kUseSubsampleEncryption,
                       &moof.tracks[1]);
   const SampleToGroupEntry kSampleToGroupTable[] = {
       // Associated with the second entry in SampleGroupDescription Box.
       // With Iv size 8 bytes.
       {1, SampleToGroupEntry::kFragmentGroupDescriptionIndexBase + 2},
       // Associated with the third entry in SampleGroupDescription Box.
       // With Iv size 16 bytes.
@@ skipping 25 matching lines @@
             config->iv());
   EXPECT_EQ(config->subsamples().size(), 2u);
   EXPECT_EQ(config->subsamples()[0].clear_bytes, 1u);
   EXPECT_EQ(config->subsamples()[0].cypher_bytes, 2u);
   EXPECT_EQ(config->subsamples()[1].clear_bytes, 3u);
   EXPECT_EQ(config->subsamples()[1].cypher_bytes, 4u);
 }
 
 TEST_F(TrackRunIteratorTest, DecryptConfigTestWithAuxInfo) {
   AddEncryption(&moov_.tracks[1]);
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
 
   MovieFragment moof = CreateFragment();
   AddAuxInfoHeaders(50, &moof.tracks[1]);
 
   ASSERT_TRUE(iter_->Init(moof));
 
   // The run for track 2 will be first, since its aux info offset is the first
   // element in the file.
   EXPECT_EQ(iter_->track_id(), 2u);
   EXPECT_TRUE(iter_->is_encrypted());
@@ skipping 26 matching lines @@
   MovieFragment moof = CreateFragment();
 
   const SampleToGroupEntry kSampleToGroupTable[] = {
       // Associated with the second entry in SampleGroupDescription Box.
       {1, SampleToGroupEntry::kFragmentGroupDescriptionIndexBase + 2},
       // Associated with the first entry in SampleGroupDescription Box.
       {1, SampleToGroupEntry::kFragmentGroupDescriptionIndexBase + 1}};
   AddCencSampleGroup(&moov_.tracks[0], &moof.tracks[0], kSampleToGroupTable,
                      arraysize(kSampleToGroupTable));
 
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
   ASSERT_TRUE(InitMoofWithArbitraryAuxInfo(&moof));
 
   std::string cenc_sample_group_key_id(
       kFragmentCencSampleGroupKeyId,
       kFragmentCencSampleGroupKeyId + arraysize(kFragmentCencSampleGroupKeyId));
   // The first sample is encrypted and the second sample is unencrypted.
   EXPECT_TRUE(iter_->is_encrypted());
   EXPECT_EQ(cenc_sample_group_key_id, iter_->GetDecryptConfig()->key_id());
   iter_->AdvanceSample();
   EXPECT_FALSE(iter_->is_encrypted());
@@ skipping 10 matching lines @@
       {2, SampleToGroupEntry::kFragmentGroupDescriptionIndexBase + 2},
       // Associated with the default values specified in TrackEncryption Box.
       {1, 0},
       // Associated with the 1st entry in fragment SampleGroupDescription Box.
       {3, SampleToGroupEntry::kFragmentGroupDescriptionIndexBase + 1},
       // Associated with the 1st entry in track SampleGroupDescription Box.
       {2, 1}};
   AddCencSampleGroup(&moov_.tracks[0], &moof.tracks[0], kSampleToGroupTable,
                      arraysize(kSampleToGroupTable));
 
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
   ASSERT_TRUE(InitMoofWithArbitraryAuxInfo(&moof));
 
   std::string track_encryption_key_id(kKeyId, kKeyId + arraysize(kKeyId));
   std::string track_cenc_sample_group_key_id(
       kTrackCencSampleGroupKeyId,
       kTrackCencSampleGroupKeyId + arraysize(kTrackCencSampleGroupKeyId));
   std::string fragment_cenc_sample_group_key_id(
       kFragmentCencSampleGroupKeyId,
       kFragmentCencSampleGroupKeyId + arraysize(kFragmentCencSampleGroupKeyId));
 
@@ skipping 25 matching lines @@
   // The remaining samples should be associated with the default values
   // specified in TrackEncryption Box.
   EXPECT_TRUE(iter_->is_encrypted());
   EXPECT_EQ(track_encryption_key_id, iter_->GetDecryptConfig()->key_id());
 }
 
 // It is legal for aux info blocks to be shared among multiple formats.
 TEST_F(TrackRunIteratorTest, SharedAuxInfoTest) {
   AddEncryption(&moov_.tracks[0]);
   AddEncryption(&moov_.tracks[1]);
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
 
   MovieFragment moof = CreateFragment();
   moof.tracks[0].runs.resize(1);
   AddAuxInfoHeaders(50, &moof.tracks[0]);
   AddAuxInfoHeaders(50, &moof.tracks[1]);
   moof.tracks[0].auxiliary_size.default_sample_info_size = 8;
 
   ASSERT_TRUE(iter_->Init(moof));
   EXPECT_EQ(iter_->track_id(), 1u);
   EXPECT_EQ(iter_->aux_info_offset(), 50);
@@ skipping 21 matching lines @@
 // unreasonable behavior demonstrated here:
 //  byte 50: track 2, run 1 aux info
 //  byte 100: track 1, run 1 data
 //  byte 200: track 2, run 1 data
 //  byte 201: track 1, run 2 aux info (*inside* track 2, run 1 data)
 //  byte 10000: track 1, run 2 data
 //  byte 20000: track 1, run 1 aux info
 TEST_F(TrackRunIteratorTest, UnexpectedOrderingTest) {
   AddEncryption(&moov_.tracks[0]);
   AddEncryption(&moov_.tracks[1]);
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
 
   MovieFragment moof = CreateFragment();
   AddAuxInfoHeaders(20000, &moof.tracks[0]);
   moof.tracks[0].auxiliary_offset.offsets.push_back(201);
   moof.tracks[0].auxiliary_size.sample_count += 2;
   moof.tracks[0].auxiliary_size.default_sample_info_size = 8;
   moof.tracks[0].runs[1].sample_count = 2;
   AddAuxInfoHeaders(50, &moof.tracks[1]);
   moof.tracks[1].runs[0].sample_sizes[0] = 5;
 
@@ skipping 23 matching lines @@
 TEST_F(TrackRunIteratorTest, KeyFrameFlagCombinations) {
   // Setup both audio and video tracks to each have 6 samples covering all the
   // combinations of mp4 "sync sample" and "depends on" relationships.
   MovieFragment moof = CreateFragment();
   moof.tracks[0].runs.resize(1);
   moof.tracks[1].runs.resize(1);
   moof.tracks[0].runs[0].sample_count = 6;
   moof.tracks[1].runs[0].sample_count = 6;
   SetFlagsOnSamples("US UN OS ON NS NN", &moof.tracks[0].runs[0]);
   SetFlagsOnSamples("US UN OS ON NS NN", &moof.tracks[1].runs[0]);
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
 
   ASSERT_TRUE(iter_->Init(moof));
   EXPECT_TRUE(iter_->IsRunValid());
 
   // Keyframes should be marked according to downstream's expectations that
   // keyframes serve as points of random access for seeking.
 
   // For audio, any sync sample should be marked as a key frame. Whether a
   // sample "depends on" other samples is not considered. Unlike video samples,
   // audio samples are often marked as depending on other samples but are still
@@ skipping 10 matching lines @@
   // marked "sync" and we must rely on combining the two flags to pick out the
   // true key frames. See http://crbug.com/310712 and http://crbug.com/507916.
   // Realiably knowing the keyframes for video is also critical to SPS PPS
   // insertion.
   EXPECT_EQ("2 K P P P K P", KeyframeAndRAPInfo(iter_.get()));
 }
 
 #if BUILDFLAG(ENABLE_CBCS_ENCRYPTION_SCHEME)
 TEST_F(TrackRunIteratorTest, DecryptConfigTestWithConstantIvNoAuxInfo) {
   AddEncryptionCbcs(&moov_.tracks[1]);
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
 
   MovieFragment moof = CreateFragment();
 
   ASSERT_TRUE(iter_->Init(moof));
 
   // The run for track 2 will be the second.
   iter_->AdvanceRun();
   EXPECT_EQ(iter_->track_id(), 2u);
   EXPECT_TRUE(iter_->is_encrypted());
   ASSERT_FALSE(iter_->AuxInfoNeedsToBeCached());
@@ skipping 27 matching lines @@
       {1, SampleToGroupEntry::kFragmentGroupDescriptionIndexBase + 2},
       // Associated with the default values specified in TrackEncryption Box.
       {1, 0},
       // Associated with the 1st entry in fragment SampleGroupDescription Box.
       {1, SampleToGroupEntry::kFragmentGroupDescriptionIndexBase + 1},
       // Associated with the 1st entry in track SampleGroupDescription Box.
       {1, 1}};
   AddCencSampleGroup(&moov_.tracks[1], &moof.tracks[1], kSampleToGroupTable,
                      arraysize(kSampleToGroupTable));
   AddConstantIvsToCencSampleGroup(&moov_.tracks[1], &moof.tracks[1]);
-  iter_.reset(new TrackRunIterator(&moov_, media_log_));
+  iter_.reset(new TrackRunIterator(&moov_, &media_log_));
   ASSERT_TRUE(iter_->Init(moof));
 
   // The run for track 2 will be the second.
   iter_->AdvanceRun();
 
   std::string track_encryption_iv(kIv3, kIv3 + arraysize(kIv3));
   std::string track_cenc_sample_group_iv(kIv4, kIv4 + arraysize(kIv4));
   std::string fragment_cenc_sample_group_iv(kIv5, kIv5 + arraysize(kIv5));
 
   for (size_t i = 0; i < kSampleToGroupTable[0].sample_count; ++i) {
@@ skipping 22 matching lines @@
   // The remaining samples should be associated with the default values
   // specified in TrackEncryption Box.
   EXPECT_TRUE(iter_->is_encrypted());
   EXPECT_EQ(track_encryption_iv, iter_->GetDecryptConfig()->iv());
 }
 
 #endif
 
 }  // namespace mp4
 }  // namespace media