Convert MediaLog from being ref counted to owned by WebMediaPlayer.

media/test/pipeline_integration_test_base.cc

 // Copyright (c) 2012 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/test/pipeline_integration_test_base.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 23 matching lines @@
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
 using ::testing::AtMost;
 using ::testing::Invoke;
 using ::testing::InvokeWithoutArgs;
 using ::testing::Return;
 using ::testing::SaveArg;
 
 namespace media {
 
+static ScopedVector<VideoDecoder> CreateVideoDecodersForTest(
+    MediaLog* media_log,
+    CreateVideoDecodersCB prepend_video_decoders_cb) {
+  ScopedVector<VideoDecoder> video_decoders;
+
+  if (!prepend_video_decoders_cb.is_null()) {
+    video_decoders = prepend_video_decoders_cb.Run();
+    DCHECK(!video_decoders.empty());
+  }
+
+#if !defined(MEDIA_DISABLE_LIBVPX)
+  video_decoders.push_back(new VpxVideoDecoder());
+#endif  // !defined(MEDIA_DISABLE_LIBVPX)
+
+// Android does not have an ffmpeg video decoder.
+#if !defined(MEDIA_DISABLE_FFMPEG) && !defined(OS_ANDROID)
+  video_decoders.push_back(new FFmpegVideoDecoder(media_log));
+#endif
+  return video_decoders;
+}
+
+static ScopedVector<AudioDecoder> CreateAudioDecodersForTest(
+    MediaLog* media_log,
+    const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
+    CreateAudioDecodersCB prepend_audio_decoders_cb) {
+  ScopedVector<AudioDecoder> audio_decoders;
+
+  if (!prepend_audio_decoders_cb.is_null()) {
+    audio_decoders = prepend_audio_decoders_cb.Run();
+    DCHECK(!audio_decoders.empty());
+  }
+
+#if !defined(MEDIA_DISABLE_FFMPEG)
+  audio_decoders.push_back(
+      new FFmpegAudioDecoder(media_task_runner, media_log));
+#endif
+  return audio_decoders;
+}
+
 const char kNullVideoHash[] = "d41d8cd98f00b204e9800998ecf8427e";
 const char kNullAudioHash[] = "0.00,0.00,0.00,0.00,0.00,0.00,";
 
 PipelineIntegrationTestBase::PipelineIntegrationTestBase()
     : hashing_enabled_(false),
       clockless_playback_(false),
-      pipeline_(new PipelineImpl(message_loop_.task_runner(), new MediaLog())),
+      pipeline_(new PipelineImpl(message_loop_.task_runner(), &media_log_)),
       ended_(false),
       pipeline_status_(PIPELINE_OK),
       last_video_frame_format_(PIXEL_FORMAT_UNKNOWN),
       last_video_frame_color_space_(COLOR_SPACE_UNSPECIFIED),
       current_duration_(kInfiniteDuration) {
   ResetVideoHash();
   EXPECT_CALL(*this, OnVideoAverageKeyframeDistanceUpdate()).Times(AnyNumber());
 }
 
 PipelineIntegrationTestBase::~PipelineIntegrationTestBase() {
@@ skipping 251 matching lines @@
   data_source_ = std::move(data_source);
 
 #if !defined(MEDIA_DISABLE_FFMPEG)
   task_scheduler_.reset(new base::test::ScopedTaskScheduler(&message_loop_));
   demuxer_ = std::unique_ptr<Demuxer>(new FFmpegDemuxer(
       message_loop_.task_runner(), data_source_.get(),
       base::Bind(&PipelineIntegrationTestBase::DemuxerEncryptedMediaInitDataCB,
                  base::Unretained(this)),
       base::Bind(&PipelineIntegrationTestBase::DemuxerMediaTracksUpdatedCB,
                  base::Unretained(this)),
-      new MediaLog()));
+      &media_log_));
 #endif
 }
 
-ScopedVector<VideoDecoder> CreateVideoDecodersForTest(
-    CreateVideoDecodersCB prepend_video_decoders_cb) {
-  ScopedVector<VideoDecoder> video_decoders;
-
-  if (!prepend_video_decoders_cb.is_null()) {
-    video_decoders = prepend_video_decoders_cb.Run();
-    DCHECK(!video_decoders.empty());
-  }
-
-#if !defined(MEDIA_DISABLE_LIBVPX)
-  video_decoders.push_back(new VpxVideoDecoder());
-#endif  // !defined(MEDIA_DISABLE_LIBVPX)
-
-// Android does not have an ffmpeg video decoder.
-#if !defined(MEDIA_DISABLE_FFMPEG) && !defined(OS_ANDROID)
-  video_decoders.push_back(
-      new FFmpegVideoDecoder(make_scoped_refptr(new MediaLog())));
-#endif
-  return video_decoders;
-}
-
-ScopedVector<AudioDecoder> CreateAudioDecodersForTest(
-    const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
-    CreateAudioDecodersCB prepend_audio_decoders_cb) {
-  ScopedVector<AudioDecoder> audio_decoders;
-
-  if (!prepend_audio_decoders_cb.is_null()) {
-    audio_decoders = prepend_audio_decoders_cb.Run();
-    DCHECK(!audio_decoders.empty());
-  }
-
-#if !defined(MEDIA_DISABLE_FFMPEG)
-  audio_decoders.push_back(
-      new FFmpegAudioDecoder(media_task_runner, new MediaLog()));
-#endif
-  return audio_decoders;
-}
-
 std::unique_ptr<Renderer> PipelineIntegrationTestBase::CreateRenderer(
     CreateVideoDecodersCB prepend_video_decoders_cb,
     CreateAudioDecodersCB prepend_audio_decoders_cb) {
   // Simulate a 60Hz rendering sink.
   video_sink_.reset(new NullVideoSink(
       clockless_playback_, base::TimeDelta::FromSecondsD(1.0 / 60),
       base::Bind(&PipelineIntegrationTestBase::OnVideoFramePaint,
                  base::Unretained(this)),
       message_loop_.task_runner()));
 
   // Disable frame dropping if hashing is enabled.
   std::unique_ptr<VideoRenderer> video_renderer(new VideoRendererImpl(
       message_loop_.task_runner(), message_loop_.task_runner().get(),
       video_sink_.get(),
-      base::Bind(&CreateVideoDecodersForTest, prepend_video_decoders_cb), false,
-      nullptr, new MediaLog()));
+      base::Bind(&CreateVideoDecodersForTest, &media_log_,
+                 prepend_video_decoders_cb),
+      false, nullptr, &media_log_));
 
   if (!clockless_playback_) {
     audio_sink_ = new NullAudioSink(message_loop_.task_runner());
   } else {
     clockless_audio_sink_ = new ClocklessAudioSink(OutputDeviceInfo(
         "", OUTPUT_DEVICE_STATUS_OK,
         // Don't allow the audio renderer to resample buffers if hashing is
         // enabled:
         hashing_enabled_
             ? AudioParameters()
             : AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY,
                               CHANNEL_LAYOUT_STEREO, 44100, 16, 512)));
   }
 
   std::unique_ptr<AudioRenderer> audio_renderer(new AudioRendererImpl(
       message_loop_.task_runner(),
       (clockless_playback_)
           ? static_cast<AudioRendererSink*>(clockless_audio_sink_.get())
           : audio_sink_.get(),
-      base::Bind(&CreateAudioDecodersForTest, message_loop_.task_runner(),
-                 prepend_audio_decoders_cb),
-      new MediaLog()));
+      base::Bind(&CreateAudioDecodersForTest, &media_log_,
+                 message_loop_.task_runner(), prepend_audio_decoders_cb),
+      &media_log_));
   if (hashing_enabled_) {
     if (clockless_playback_)
       clockless_audio_sink_->StartAudioHashForTesting();
     else
       audio_sink_->StartAudioHashForTesting();
   }
 
   std::unique_ptr<RendererImpl> renderer_impl(
       new RendererImpl(message_loop_.task_runner(), std::move(audio_renderer),
                        std::move(video_renderer)));
@@ skipping 57 matching lines @@
   DCHECK(clockless_playback_);
   return clockless_audio_sink_->render_time();
 }
 
 base::TimeTicks DummyTickClock::NowTicks() {
   now_ += base::TimeDelta::FromSeconds(60);
   return now_;
 }
 
 }  // namespace media