Convert MediaLog from being ref counted to owned by WebMediaPlayer.

media/filters/frame_processor_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 <map>
 #include <string>
 #include <vector>
@@ skipping 47 matching lines @@
 
 // Test parameter determines indicates if the TEST_P instance is targeted for
 // sequence mode (if true), or segments mode (if false).
 class FrameProcessorTest : public testing::TestWithParam<bool> {
  protected:
   FrameProcessorTest()
       : frame_processor_(new FrameProcessor(
             base::Bind(
                 &FrameProcessorTestCallbackHelper::OnPossibleDurationIncrease,
                 base::Unretained(&callbacks_)),
-            new MediaLog())),
+            &media_log_)),
         append_window_end_(kInfiniteDuration),
         frame_duration_(base::TimeDelta::FromMilliseconds(10)),
         audio_id_(1),
         video_id_(2) {}
 
   enum StreamFlags {
     HAS_AUDIO = 1 << 0,
     HAS_VIDEO = 1 << 1
   };
 
@@ skipping 178 matching lines @@
            kNoDecodeTimestamp();
   }
 
   void seek(ChunkDemuxerStream* stream, base::TimeDelta seek_time) {
     stream->AbortReads();
     stream->Seek(seek_time);
     stream->StartReturningData();
   }
 
   base::MessageLoop message_loop_;
+  MediaLog media_log_;
   StrictMock<FrameProcessorTestCallbackHelper> callbacks_;
 
   std::unique_ptr<FrameProcessor> frame_processor_;
   base::TimeDelta append_window_start_;
   base::TimeDelta append_window_end_;
   base::TimeDelta timestamp_offset_;
   base::TimeDelta frame_duration_;
   std::unique_ptr<ChunkDemuxerStream> audio_;
   std::unique_ptr<ChunkDemuxerStream> video_;
   const TrackId audio_id_;
@@ skipping 23 matching lines @@
   void CreateAndConfigureStream(DemuxerStream::Type type) {
     // TODO(wolenetz/dalecurtis): Also test with splicing disabled?
     switch (type) {
       case DemuxerStream::AUDIO: {
         ASSERT_FALSE(audio_);
         audio_.reset(new ChunkDemuxerStream(DemuxerStream::AUDIO, "1"));
         AudioDecoderConfig decoder_config(kCodecVorbis, kSampleFormatPlanarF32,
                                           CHANNEL_LAYOUT_STEREO, 1000,
                                           EmptyExtraData(), Unencrypted());
         frame_processor_->OnPossibleAudioConfigUpdate(decoder_config);
-        ASSERT_TRUE(audio_->UpdateAudioConfig(decoder_config, new MediaLog()));
+        ASSERT_TRUE(audio_->UpdateAudioConfig(decoder_config, &media_log_));
         break;
       }
       case DemuxerStream::VIDEO: {
         ASSERT_FALSE(video_);
         video_.reset(new ChunkDemuxerStream(DemuxerStream::VIDEO, "2"));
-        ASSERT_TRUE(video_->UpdateVideoConfig(TestVideoConfig::Normal(),
-                                              new MediaLog()));
+        ASSERT_TRUE(
+            video_->UpdateVideoConfig(TestVideoConfig::Normal(), &media_log_));
         break;
       }
       // TODO(wolenetz): Test text coded frame processing.
       case DemuxerStream::TEXT:
       case DemuxerStream::UNKNOWN: {
         ASSERT_FALSE(true);
       }
     }
   }
 
@@ skipping 570 matching lines @@
   StreamParserBuffer* last_read_parser_buffer =
       static_cast<StreamParserBuffer*>(last_read_buffer_.get());
   ASSERT_EQ(base::TimeDelta::FromMilliseconds(0),
             last_read_parser_buffer->preroll_buffer()->duration());
 }
 
 INSTANTIATE_TEST_CASE_P(SequenceMode, FrameProcessorTest, Values(true));
 INSTANTIATE_TEST_CASE_P(SegmentsMode, FrameProcessorTest, Values(false));
 
 }  // namespace media