Convert MediaLog from being ref counted to owned by WebMediaPlayer.

content/browser/media/media_internals_unittest.cc

 // Copyright (c) 2011 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 "content/browser/media/media_internals.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 303 matching lines @@
     MediaInternalsAudioLogTest,
     testing::Values(media::AudioLogFactory::AUDIO_INPUT_CONTROLLER,
                     media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER,
                     media::AudioLogFactory::AUDIO_OUTPUT_STREAM));
 
 class DirectMediaLog : public media::MediaLog {
  public:
   explicit DirectMediaLog(int render_process_id)
       : render_process_id_(render_process_id),
         internals_(content::MediaInternals::GetInstance()) {}
+  ~DirectMediaLog() override {}
 
   void AddEvent(std::unique_ptr<media::MediaLogEvent> event) override {
     std::vector<media::MediaLogEvent> events(1, *event);
     internals_->OnMediaEvents(render_process_id_, events);
   }
 
  private:
-  ~DirectMediaLog() override {}
-
   const int render_process_id_;
   MediaInternals* const internals_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectMediaLog);
 };
 
 class MediaInternalsWatchTimeTest : public testing::Test,
                                     public MediaInternalsTestBase {
  public:
   MediaInternalsWatchTimeTest()
       : render_process_id_(0),
         internals_(content::MediaInternals::GetInstance()),
         media_log_(new DirectMediaLog(render_process_id_)),
         histogram_tester_(new base::HistogramTester()),
         watch_time_keys_(media::MediaLog::GetWatchTimeKeys()),
         watch_time_power_keys_(media::MediaLog::GetWatchTimePowerKeys()) {}
 
   void Initialize(bool has_audio,
                   bool has_video,
                   bool is_mse,
                   bool is_encrypted) {
     wtr_.reset(new media::WatchTimeReporter(
-        has_audio, has_video, is_mse, is_encrypted, true, media_log_,
+        has_audio, has_video, is_mse, is_encrypted, true, media_log_.get(),
         gfx::Size(800, 600),
         base::Bind(&MediaInternalsWatchTimeTest::GetCurrentMediaTime,
                    base::Unretained(this))));
     wtr_->set_reporting_interval_for_testing();
   }
 
   void CycleWatchTimeReporter() {
     base::RunLoop run_loop;
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   run_loop.QuitClosure());
@@ skipping 15 matching lines @@
 
   void ResetHistogramTester() {
     histogram_tester_.reset(new base::HistogramTester());
   }
 
   MOCK_METHOD0(GetCurrentMediaTime, base::TimeDelta());
 
  protected:
   const int render_process_id_;
   MediaInternals* const internals_;
-  scoped_refptr<DirectMediaLog> media_log_;
+  std::unique_ptr<DirectMediaLog> media_log_;
   std::unique_ptr<base::HistogramTester> histogram_tester_;
   std::unique_ptr<media::WatchTimeReporter> wtr_;
   const base::flat_set<base::StringPiece> watch_time_keys_;
   const base::flat_set<base::StringPiece> watch_time_power_keys_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaInternalsWatchTimeTest);
 };
 
 TEST_F(MediaInternalsWatchTimeTest, BasicAudio) {
   constexpr base::TimeDelta kWatchTimeEarly = base::TimeDelta::FromSeconds(5);
@@ skipping 176 matching lines @@
   internals_->OnProcessTerminatedForTesting(render_process_id_);
   ExpectWatchTime({media::MediaLog::kWatchTimeAudioVideoAll,
                    media::MediaLog::kWatchTimeAudioVideoSrc,
                    media::MediaLog::kWatchTimeAudioVideoEme,
                    media::MediaLog::kWatchTimeAudioVideoAc,
                    media::MediaLog::kWatchTimeAudioVideoEmbeddedExperience},
                   kWatchTimeLate);
 }
 
 }  // namespace content