Convert MediaLog from being ref counted to owned by WebMediaPlayer.

media/blink/watch_time_reporter.h

 // Copyright 2016 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.
 
 #ifndef MEDIA_BLINK_WATCH_TIME_REPORTER_H_
 #define MEDIA_BLINK_WATCH_TIME_REPORTER_H_
 
 #include "base/callback.h"
 #include "base/power_monitor/power_observer.h"
 #include "base/time/time.h"
@@ skipping 48 matching lines @@
   // time, not wall clock time! Using media time instead of wall clock time
   // allows us to avoid a whole class of issues around clock changes during
   // suspend and resume.
   // TODO(dalecurtis): Should we only report when rate == 1.0? Should we scale
   // the elapsed media time instead?
   WatchTimeReporter(bool has_audio,
                     bool has_video,
                     bool is_mse,
                     bool is_encrypted,
                     bool is_embedded_media_experience_enabled,
-                    scoped_refptr<MediaLog> media_log,
+                    MediaLog* media_log,
                     const gfx::Size& initial_video_size,
                     const GetMediaTimeCB& get_media_time_cb);
   ~WatchTimeReporter() override;
 
   // These methods are used to ensure that watch time is only reported for
   // media that is actually playing. They should be called whenever the media
   // starts or stops playing for any reason. If the media is audio+video and
   // currently hidden, OnPlaying() will start background watch time reporting.
   void OnPlaying();
   void OnPaused();
@@ skipping 43 matching lines @@
 
  private:
   friend class WatchTimeReporterTest;
 
   // Internal constructor for marking background status.
   WatchTimeReporter(bool has_audio,
                     bool has_video,
                     bool is_mse,
                     bool is_encrypted,
                     bool is_embedded_media_experience_enabled,
-                    scoped_refptr<MediaLog> media_log,
+                    MediaLog* media_log,
                     const gfx::Size& initial_video_size,
                     const GetMediaTimeCB& get_media_time_cb,
                     bool is_background);
 
   // base::PowerObserver implementation.
   //
   // We only observe power source changes. We don't need to observe suspend and
   // resume events because we report watch time in terms of elapsed media time
   // and not in terms of elapsed real time.
   void OnPowerStateChange(bool on_battery_power) override;
 
   bool ShouldReportWatchTime();
   void MaybeStartReportingTimer(base::TimeDelta start_timestamp);
   enum class FinalizeTime { IMMEDIATELY, ON_NEXT_UPDATE };
   void MaybeFinalizeWatchTime(FinalizeTime finalize_time);
   void UpdateWatchTime();
 
   // Initialized during construction.
   const bool has_audio_;
   const bool has_video_;
   const bool is_mse_;
   const bool is_encrypted_;
   const bool is_embedded_media_experience_enabled_;
-  scoped_refptr<MediaLog> media_log_;
+  MediaLog* media_log_;
   const gfx::Size initial_video_size_;
   const GetMediaTimeCB get_media_time_cb_;
   const bool is_background_;
 
   // The amount of time between each UpdateWatchTime(); this is the frequency by
   // which the watch times are updated. In the event of a process crash or kill
   // this is also the most amount of watch time that we might lose.
   base::TimeDelta reporting_interval_ = base::TimeDelta::FromSeconds(5);
 
   base::RepeatingTimer reporting_timer_;
@@ skipping 20 matching lines @@
   // Special case reporter for handling background video watch time. Configured
   // as an audio only WatchTimeReporter with |is_background_| set to true.
   std::unique_ptr<WatchTimeReporter> background_reporter_;
 
   DISALLOW_COPY_AND_ASSIGN(WatchTimeReporter);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_WATCH_TIME_REPORTER_H_