media/mojo/services/media_metrics_provider.h

   1 // Copyright 2017 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MEDIA_MOJO_SERVICES_MEDIA_METRICS_PROVIDER_H_
   6 #define MEDIA_MOJO_SERVICES_MEDIA_METRICS_PROVIDER_H_
   7
   8 #include <stdint.h>
   9 #include <string>
  10
  11 #include "base/time/time.h"
  12 #include "media/base/container_names.h"
  13 #include "media/base/pipeline_status.h"
  14 #include "media/base/renderer_factory_selector.h"
  15 #include "media/base/timestamp_constants.h"
  16 #include "media/learning/common/learning_session.h"
  17 #include "media/learning/common/value.h"
  18 #include "media/mojo/mojom/media_metrics_provider.mojom.h"
  19 #include "media/mojo/services/media_mojo_export.h"
  20 #include "media/mojo/services/video_decode_perf_history.h"
  21 #include "mojo/public/cpp/bindings/pending_receiver.h"
  22 #include "services/metrics/public/cpp/ukm_source_id.h"
  23 #include "third_party/abseil-cpp/absl/types/optional.h"
  24 #include "url/gurl.h"
  25
  26 namespace media {
  27
  28 class VideoDecodePerfHistory;
  29
  30 // See mojom::MediaMetricsProvider for documentation.
  31 class MEDIA_MOJO_EXPORT MediaMetricsProvider
  32     : public mojom::MediaMetricsProvider {
  33  public:
  34   enum class BrowsingMode : bool { kIncognito, kNormal };
  35
  36   enum class FrameStatus : bool { kTopFrame, kNotTopFrame };
  37
  38   using GetLearningSessionCallback =
  39       base::RepeatingCallback<learning::LearningSession*()>;
  40
  41   using RecordAggregateWatchTimeCallback =
  42       base::RepeatingCallback<void(base::TimeDelta total_watch_time,
  43                                    base::TimeDelta time_stamp,
  44                                    bool has_video,
  45                                    bool has_audio)>;
  46
  47   using GetRecordAggregateWatchTimeCallback =
  48       base::RepeatingCallback<RecordAggregateWatchTimeCallback(void)>;
  49
  50   using IsShuttingDownCallback = base::RepeatingCallback<bool(void)>;
  51
  52   MediaMetricsProvider(BrowsingMode is_incognito,
  53                        FrameStatus is_top_frame,
  54                        ukm::SourceId source_id,
  55                        learning::FeatureValue origin,
  56                        VideoDecodePerfHistory::SaveCallback save_cb,
  57                        GetLearningSessionCallback learning_session_cb,
  58                        RecordAggregateWatchTimeCallback record_playback_cb,
  59                        IsShuttingDownCallback is_shutting_down_cb);
  60
  61   MediaMetricsProvider(const MediaMetricsProvider&) = delete;
  62   MediaMetricsProvider& operator=(const MediaMetricsProvider&) = delete;
  63
  64   ~MediaMetricsProvider() override;
  65
  66   // Callback for retrieving a ukm::SourceId.
  67   using GetSourceIdCallback = base::RepeatingCallback<ukm::SourceId(void)>;
  68
  69   using GetLastCommittedURLCallback =
  70       base::RepeatingCallback<const GURL&(void)>;
  71
  72   // TODO(liberato): This should be from a FeatureProvider, but the way in which
  73   // we attach LearningHelper more or less precludes it.  Per-frame task
  74   // controllers would make this easy, but we bypass that here.
  75   using GetOriginCallback =
  76       base::RepeatingCallback<learning::FeatureValue(void)>;
  77
  78   // Creates a MediaMetricsProvider, |perf_history| may be nullptr if perf
  79   // history database recording is disabled.
  80   static void Create(
  81       BrowsingMode is_incognito,
  82       FrameStatus is_top_frame,
  83       ukm::SourceId source_id,
  84       learning::FeatureValue origin,
  85       VideoDecodePerfHistory::SaveCallback save_cb,
  86       GetLearningSessionCallback learning_session_cb,
  87       GetRecordAggregateWatchTimeCallback get_record_playback_cb,
  88       IsShuttingDownCallback is_shutting_down_cb,
  89       mojo::PendingReceiver<mojom::MediaMetricsProvider> receiver);
  90
  91  private:
  92   struct PipelineInfo {
  93     explicit PipelineInfo(bool is_incognito);
  94     ~PipelineInfo();
  95     bool is_incognito;
  96     bool has_ever_played = false;
  97     bool has_reached_have_enough = false;
  98     bool has_audio = false;
  99     bool has_video = false;
 100     bool is_eme = false;
 101     bool video_decoder_changed = false;
 102     AudioCodec audio_codec = AudioCodec::kUnknown;
 103     VideoCodec video_codec = VideoCodec::kUnknown;
 104     VideoPipelineInfo video_pipeline_info;
 105     AudioPipelineInfo audio_pipeline_info;
 106     PipelineStatusCodes last_pipeline_status = PIPELINE_OK;
 107   };
 108
 109   struct MediaInfo {
 110     const bool is_mse;
 111     const mojom::MediaURLScheme url_scheme;
 112     const mojom::MediaStreamType media_stream_type;
 113   };
 114
 115   // mojom::MediaMetricsProvider implementation:
 116   void Initialize(bool is_mse,
 117                   mojom::MediaURLScheme url_scheme,
 118                   mojom::MediaStreamType media_stream_type) override;
 119   void OnError(const PipelineStatus& status) override;
 120   void OnFallback(const PipelineStatus& status) override;
 121   void SetAudioPipelineInfo(const AudioPipelineInfo& info) override;
 122   void SetContainerName(
 123       container_names::MediaContainerName container_name) override;
 124   void SetRendererType(RendererType renderer_type) override;
 125   void SetKeySystem(const std::string& key_system) override;
 126   void SetIsHardwareSecure() override;
 127   void SetHasAudio(AudioCodec audio_codec) override;
 128   void SetHasPlayed() override;
 129   void SetHasVideo(VideoCodec video_codec) override;
 130   void SetHaveEnough() override;
 131   void SetIsEME() override;
 132   void SetTimeToMetadata(base::TimeDelta elapsed) override;
 133   void SetTimeToFirstFrame(base::TimeDelta elapsed) override;
 134   void SetTimeToPlayReady(base::TimeDelta elapsed) override;
 135   void SetVideoPipelineInfo(const VideoPipelineInfo& info) override;
 136
 137   void AcquireWatchTimeRecorder(
 138       mojom::PlaybackPropertiesPtr properties,
 139       mojo::PendingReceiver<mojom::WatchTimeRecorder> receiver) override;
 140   void AcquireVideoDecodeStatsRecorder(
 141       mojo::PendingReceiver<mojom::VideoDecodeStatsRecorder> receiver) override;
 142   void AcquirePlaybackEventsRecorder(
 143       mojo::PendingReceiver<mojom::PlaybackEventsRecorder> receiver) override;
 144   void AcquireLearningTaskController(
 145       const std::string& taskName,
 146       mojo::PendingReceiver<learning::mojom::LearningTaskController> receiver)
 147       override;
 148
 149   void ReportPipelineUMA();
 150   std::string GetUMANameForAVStream(const PipelineInfo& player_info);
 151
 152   bool IsInitialized() const;
 153
 154   // Session unique ID which maps to a given WebMediaPlayerImpl instances. Used
 155   // to coordinate multiply logged events with a singly logged metric.
 156   const uint64_t player_id_;
 157
 158   // Are UKM reports for the main frame or for a subframe?
 159   const bool is_top_frame_;
 160
 161   const ukm::SourceId source_id_;
 162   const learning::FeatureValue origin_;
 163
 164   const VideoDecodePerfHistory::SaveCallback save_cb_;
 165   const GetLearningSessionCallback learning_session_cb_;
 166   const RecordAggregateWatchTimeCallback record_playback_cb_;
 167   const IsShuttingDownCallback is_shutting_down_cb_;
 168
 169   // UMA pipeline packaged data
 170   PipelineInfo uma_info_;
 171
 172   // The values below are only set if `Initialize` has been called.
 173   absl::optional<MediaInfo> media_info_;
 174
 175   RendererType renderer_type_ = RendererType::kRendererImpl;
 176   std::string key_system_;
 177   bool is_hardware_secure_ = false;
 178
 179   base::TimeDelta time_to_metadata_ = kNoTimestamp;
 180   base::TimeDelta time_to_first_frame_ = kNoTimestamp;
 181   base::TimeDelta time_to_play_ready_ = kNoTimestamp;
 182
 183   absl::optional<container_names::MediaContainerName> container_name_;
 184 };
 185
 186 }  // namespace media
 187
 188 #endif  // MEDIA_MOJO_SERVICES_MEDIA_METRICS_PROVIDER_H_