Piggybacking simulcast id and ALR experiment id into video content type extension.

webrtc/video/receive_statistics_proxy.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/video/receive_statistics_proxy.h"
 
 #include <algorithm>
 #include <cmath>
+#include <sstream>
 #include <utility>
 
+#include "webrtc/modules/pacing/alr_detector.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
 namespace {
 // Periodic time interval for processing samples for |freq_offset_counter_|.
@@ skipping 14 matching lines @@
 const int kLowQpThresholdVp8 = 60;
 const int kHighQpThresholdVp8 = 70;
 const int kLowVarianceThreshold = 1;
 const int kHighVarianceThreshold = 2;
 
 // Some metrics are reported as a maximum over this period.
 const int kMovingMaxWindowMs = 10000;
 
 // How large window we use to calculate the framerate/bitrate.
 const int kRateStatisticsWindowSizeMs = 1000;
+
+std::string UmaPrefixForContentType(VideoContentType content_type) {
+  std::stringstream ss;
+  ss << "WebRTC.Video";
+  if (content_type.IsScreenshare()) {
+    ss << ".Screenshare";
+  }
+  return ss.str();
+}
+
+std::string UmaSpatialSuffixForContentType(VideoContentType content_type) {
+  std::stringstream ss;
+  int simulcast_id = content_type.GetSimulcastId();
+  if (simulcast_id > 0) {
+    ss << ".S" << simulcast_id - 1;
+  }
+  return ss.str();
+}
+
+std::string UmaExperimentSuffixForConentType(VideoContentType content_type) {
+  std::stringstream ss;
+  int experiment_id = content_type.GetExperimentId();
+  if (experiment_id > 0) {
+    ss << ".ExperimentGroup" << experiment_id - 1;
+  }
+  return ss.str();
+}
 }  // namespace
 
 ReceiveStatisticsProxy::ReceiveStatisticsProxy(
     const VideoReceiveStream::Config* config,
     Clock* clock)
     : clock_(clock),
       config_(*config),
       start_ms_(clock->TimeInMilliseconds()),
       last_sample_time_(clock->TimeInMilliseconds()),
       fps_threshold_(kLowFpsThreshold,
                      kHighFpsThreshold,
                      kBadFraction,
                      kNumMeasurements),
       qp_threshold_(kLowQpThresholdVp8,
                     kHighQpThresholdVp8,
                     kBadFraction,
                     kNumMeasurements),
       variance_threshold_(kLowVarianceThreshold,
                           kHighVarianceThreshold,
                           kBadFraction,
                           kNumMeasurementsVariance),
       num_bad_states_(0),
       num_certain_states_(0),
       // 1000ms window, scale 1000 for ms to s.
       decode_fps_estimator_(1000, 1000),
       renders_fps_estimator_(1000, 1000),
       render_fps_tracker_(100, 10u),
       render_pixel_tracker_(100, 10u),
       total_byte_tracker_(100, 10u),  // bucket_interval_ms, bucket_count
-      e2e_delay_max_ms_video_(-1),
-      e2e_delay_max_ms_screenshare_(-1),
-      interframe_delay_max_ms_video_(-1),
-      interframe_delay_max_ms_screenshare_(-1),
       interframe_delay_max_moving_(kMovingMaxWindowMs),
       freq_offset_counter_(clock, nullptr, kFreqOffsetProcessIntervalMs),
       first_report_block_time_ms_(-1),
       avg_rtt_ms_(0),
       last_content_type_(VideoContentType::UNSPECIFIED) {
   stats_.ssrc = config_.rtp.remote_ssrc;
   // TODO(brandtr): Replace |rtx_stats_| with a single instance of
   // StreamDataCounters.
   if (config_.rtp.rtx_ssrc) {
     rtx_stats_[config_.rtp.rtx_ssrc] = StreamDataCounters();
   }
 }
 
 ReceiveStatisticsProxy::~ReceiveStatisticsProxy() {
   UpdateHistograms();
 }
 
 void ReceiveStatisticsProxy::UpdateHistograms() {
-  RTC_HISTOGRAM_COUNTS_100000(
-      "WebRTC.Video.ReceiveStreamLifetimeInSeconds",
-      (clock_->TimeInMilliseconds() - start_ms_) / 1000);
+  const int kMinRequiredSamples = 200;
 
-  if (first_report_block_time_ms_ != -1 &&
-      ((clock_->TimeInMilliseconds() - first_report_block_time_ms_) / 1000) >=
-          metrics::kMinRunTimeInSeconds) {
-    int fraction_lost = report_block_stats_.FractionLostInPercent();
-    if (fraction_lost != -1) {
-      RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.ReceivedPacketsLostInPercent",
-                               fraction_lost);
-      LOG(LS_INFO) << "WebRTC.Video.ReceivedPacketsLostInPercent "
-                   << fraction_lost;
-    }
-  }
-
-  const int kMinRequiredSamples = 200;
   int samples = static_cast<int>(render_fps_tracker_.TotalSampleCount());
   if (samples >= kMinRequiredSamples) {
     RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.RenderFramesPerSecond",
                              round(render_fps_tracker_.ComputeTotalRate()));
     RTC_HISTOGRAM_COUNTS_100000(
         "WebRTC.Video.RenderSqrtPixelsPerSecond",
         round(render_pixel_tracker_.ComputeTotalRate()));
   }
+
+  // Slice on content type and simulcast id.
+  for (auto it : content_specific_stats_) {

[sprang_webrtc, 2017/08/28 07:58:30]

I think it would be good with a comment outlining clearly how we're trying to
slice this. For instance, for the metric Foo we get the following slices:

WebRTC.Video.Foo.S[0-3]
WebRTC.Video.Foo.ExperimentGroup[0-7]
WebRTC.Video.Screenshare.Foo.S[0-3]
WebRTC.Video.Screenshare.Foo.ExperimentGroup[0-7]

[ilnik, 2017/08/28 14:54:34]

Should be more clear now.

+    auto content_type = it.first;
+    if (content_type.GetExperimentId() == 0 &&
+        content_type.GetSimulcastId() == 0) {
+      // Name of a metric sliced on simulcast is the same as sliced on
+      // experiment because no slice information is available in both cases.
+      // Don't report the metric here to not duplicate the metric.
+      continue;
+    }
+    auto stats = it.second;
+    std::string uma_prefix = UmaPrefixForContentType(content_type);
+    std::string uma_suffix = UmaSpatialSuffixForContentType(content_type);

[sprang_webrtc, 2017/08/28 07:58:30]

Will this work? If we slice on experiment and spatial layer separately (per
content type), say we want to show the stats for spatial layer 1, shouldn't we
then aggregate all content specific stats where spatial layer is 1?

[ilnik, 2017/08/28 14:54:34]

Done.

+    // The same line of code can't report different histograms because of how
+    // macro is done. Additional index needed to be different for all different
+    // names. Since experiment can't change during call, we could report 4*2

[sprang_webrtc, 2017/08/28 07:58:30]

Experiments can change during a call....

[ilnik, 2017/08/28 14:54:34]

Done.

+    // different content types (4 simulcast_ids x 2 content types).
+    // Conveniently all of these are stored in 3 lower bits in VideoContentType.
+    int idx = content_type.content_type & 0x07;

[sprang_webrtc, 2017/08/28 07:58:30]

This is starting to get cluttered. Could we move the actual histogram reporting
to a separate method, taking a ContentSpecificStats reference and prefix/suffix
as argument?

Or some way to merge it with the reporting below, so that we only report say
EndToEndDelayInMs in only one place.

[ilnik, 2017/08/28 14:54:34]

Reporting below is removed (except for 3 already existing metrics to not change
them).

+    int e2e_delay_ms = stats.e2e_delay_counter.Avg(kMinRequiredSamples);
+    if (e2e_delay_ms != -1) {
+      RTC_HISTOGRAMS_COUNTS_10000(
+          idx, uma_prefix + ".EndToEndDelayInMs" + uma_suffix, e2e_delay_ms);
+      LOG(LS_INFO) << uma_prefix << ".EndToEndDelayInMs" << uma_suffix << " "
+                   << e2e_delay_ms;
+    }
+    int e2e_delay_max_ms = stats.e2e_delay_counter.Max();
+    if (e2e_delay_max_ms != -1 && e2e_delay_ms != -1) {
+      RTC_HISTOGRAMS_COUNTS_100000(
+          idx, uma_prefix + ".EndToEndDelayMaxInMs" + uma_suffix,
+          e2e_delay_max_ms);
+      LOG(LS_INFO) << uma_prefix << ".EndToEndDelayMaxInMs" << uma_suffix << " "
+                   << e2e_delay_max_ms;
+    }
+    int interframe_delay_ms =
+        stats.interframe_delay_counter.Avg(kMinRequiredSamples);
+    if (interframe_delay_ms != -1) {
+      RTC_HISTOGRAMS_COUNTS_10000(
+          idx, uma_prefix + ".InterframeDelayInMs" + uma_suffix,
+          interframe_delay_ms);
+      LOG(LS_INFO) << uma_prefix << ".InterframeDelayInMs" << uma_suffix << " "
+                   << interframe_delay_ms;
+    }
+    int interframe_delay_max_ms = stats.interframe_delay_counter.Max();
+    if (interframe_delay_max_ms != -1 && interframe_delay_ms != -1) {
+      RTC_HISTOGRAMS_COUNTS_10000(
+          idx, uma_prefix + ".InterframeDelayMaxInMs" + uma_suffix,
+          interframe_delay_max_ms);
+      LOG(LS_INFO) << uma_prefix << ".InterframeDelayMaxInMs" << uma_suffix
+                   << " " << interframe_delay_max_ms;
+    }
+
+    float flow_duration_sec = stats.flow_duration_ms / 1000.0;
+    if (flow_duration_sec >= metrics::kMinRunTimeInSeconds) {
+      int media_bitrate_kbps = static_cast<int>(stats.total_media_bytes * 8 /
+                                                flow_duration_sec / 1000);
+      RTC_HISTOGRAM_COUNTS_10000(
+          uma_prefix + ".MediaBitrateReceivedInKbps" + uma_suffix,
+          media_bitrate_kbps);
+      LOG(LS_INFO) << uma_prefix << ".MediaBitrateReceivedInKbps" << uma_suffix
+                   << " " << media_bitrate_kbps;
+    }
+
+    int qp = stats.qp_counter.Avg(kMinRequiredSamples);
+    if (qp != -1) {
+      RTC_HISTOGRAMS_COUNTS_200(
+          idx, uma_prefix + ".Decoded.Vp8.Qp" + uma_suffix, qp);
+      LOG(LS_INFO) << uma_prefix << ".Decoded.Vp8.Qp" << uma_suffix << " "
+                   << qp;
+    }
+
+    int width = stats.received_width.Avg(kMinRequiredSamples);
+    if (width != -1) {
+      RTC_HISTOGRAMS_COUNTS_10000(
+          idx, uma_prefix + ".ReceivedWidthInPixels" + uma_suffix, width);
+      LOG(LS_INFO) << uma_prefix << ".ReceivedWidthInPixels" << uma_suffix
+                   << " " << width;
+    }
+
+    int height = stats.received_height.Avg(kMinRequiredSamples);
+    if (height != -1) {
+      RTC_HISTOGRAMS_COUNTS_10000(
+          idx, uma_prefix + ".ReceivedHeightInPixels" + uma_suffix, height);
+      LOG(LS_INFO) << uma_prefix << ".ReceivedHeightInPixels" << uma_suffix
+                   << " " << height;
+    }
+  }
+
+  // Metrics sliced on experiment are not sliced on screenshare/realtime video.
+  std::string uma_prefix = UmaPrefixForContentType(
+      VideoContentType::UNSPECIFIED);
+  std::string uma_experiment_suffix =
+      UmaExperimentSuffixForConentType(last_content_type_);
+  int idx = last_content_type_.GetExperimentId();
+
+  if (first_report_block_time_ms_ != -1 &&
+      ((clock_->TimeInMilliseconds() - first_report_block_time_ms_) / 1000) >=
+          metrics::kMinRunTimeInSeconds) {
+    int fraction_lost = report_block_stats_.FractionLostInPercent();
+    if (fraction_lost != -1) {
+      RTC_HISTOGRAMS_PERCENTAGE(
+          idx,
+          uma_prefix + ".ReceivedPacketsLostInPercent" + uma_experiment_suffix,
+          fraction_lost);
+      LOG(LS_INFO) << uma_prefix << ".ReceivedPacketsLostInPercent"
+                   << uma_experiment_suffix << " " << fraction_lost;
+    }
+  }
+
+  int stream_duration_sec = (clock_->TimeInMilliseconds() - start_ms_) / 1000;
+  RTC_HISTOGRAMS_COUNTS_100000(
+      idx,
+      uma_prefix + ".ReceiveStreamLifetimeInSeconds" + uma_experiment_suffix,
+      stream_duration_sec);
+  LOG(LS_INFO) << uma_prefix << ".ReceiveStreamLifetimeInSeconds"
+               << uma_experiment_suffix << " " << stream_duration_sec;
+
+  int e2e_delay_ms = e2e_delay_counter.Avg(kMinRequiredSamples);
+  if (e2e_delay_ms != -1) {
+    RTC_HISTOGRAMS_COUNTS_10000(
+        idx, uma_prefix + ".EndToEndDelayInMs" + uma_experiment_suffix,
+        e2e_delay_ms);
+    LOG(LS_INFO) << uma_prefix << ".EndToEndDelayInMs" << uma_experiment_suffix
+                 << " " << e2e_delay_ms;
+  }
+  int e2e_delay_max_ms = e2e_delay_counter.Max();
+  if (e2e_delay_max_ms != -1 && e2e_delay_ms != -1) {
+    RTC_HISTOGRAMS_COUNTS_100000(
+        idx, uma_prefix + ".EndToEndDelayMaxInMs" + uma_experiment_suffix,
+        e2e_delay_max_ms);
+    LOG(LS_INFO) << uma_prefix << ".EndToEndDelayMaxInMs"
+                 << uma_experiment_suffix << " " << e2e_delay_max_ms;
+  }
+  int interframe_delay_ms = interframe_delay_counter.Avg(kMinRequiredSamples);
+  if (interframe_delay_ms != -1) {
+    RTC_HISTOGRAMS_COUNTS_10000(
+        idx, uma_prefix + ".InterframeDelayInMs" + uma_experiment_suffix,
+        interframe_delay_ms);
+    LOG(LS_INFO) << uma_prefix << ".InterframeDelayInMs"
+                 << uma_experiment_suffix << " " << interframe_delay_ms;
+  }
+  int interframe_delay_max_ms = interframe_delay_counter.Max();
+  if (interframe_delay_max_ms != -1 && interframe_delay_ms != -1) {
+    RTC_HISTOGRAMS_COUNTS_10000(
+        idx, uma_prefix + ".InterframeDelayMaxInMs" + uma_experiment_suffix,
+        interframe_delay_max_ms);
+    LOG(LS_INFO) << uma_prefix << ".InterframeDelayMaxInMs"
+                 << uma_experiment_suffix << " " << interframe_delay_max_ms;
+  }
+
   int width = render_width_counter_.Avg(kMinRequiredSamples);
   int height = render_height_counter_.Avg(kMinRequiredSamples);
   if (width != -1) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.ReceivedWidthInPixels", width);
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.ReceivedHeightInPixels", height);
-    LOG(LS_INFO) << "WebRTC.Video.ReceivedWidthInPixels " << width;
-    LOG(LS_INFO) << "WebRTC.Video.ReceivedHeightInPixels " << height;
+    RTC_HISTOGRAMS_COUNTS_10000(
+        idx, uma_prefix + ".ReceivedWidthInPixels" + uma_experiment_suffix,
+        width);
+    RTC_HISTOGRAMS_COUNTS_10000(
+        idx, uma_prefix + ".ReceivedHeightInPixels" + uma_experiment_suffix,
+        height);
+    LOG(LS_INFO) << uma_prefix << ".ReceivedWidthInPixels"
+                 << uma_experiment_suffix << " " << width;
+    LOG(LS_INFO) << uma_prefix << ".ReceivedHeightInPixels"
+                 << uma_experiment_suffix << " " << height;
   }
   int sync_offset_ms = sync_offset_counter_.Avg(kMinRequiredSamples);
   if (sync_offset_ms != -1) {
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.AVSyncOffsetInMs", sync_offset_ms);
     LOG(LS_INFO) << "WebRTC.Video.AVSyncOffsetInMs " << sync_offset_ms;
   }
   AggregatedStats freq_offset_stats = freq_offset_counter_.GetStats();
   if (freq_offset_stats.num_samples > 0) {
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.RtpToNtpFreqOffsetInKhz",
                                freq_offset_stats.average);
     LOG(LS_INFO) << "WebRTC.Video.RtpToNtpFreqOffsetInKhz, "
                  << freq_offset_stats.ToString();
   }
 
   int num_total_frames =
       stats_.frame_counts.key_frames + stats_.frame_counts.delta_frames;
   if (num_total_frames >= kMinRequiredSamples) {
     int num_key_frames = stats_.frame_counts.key_frames;
     int key_frames_permille =
         (num_key_frames * 1000 + num_total_frames / 2) / num_total_frames;
-    RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.KeyFramesReceivedInPermille",
-                              key_frames_permille);
-    LOG(LS_INFO) << "WebRTC.Video.KeyFramesReceivedInPermille "
-                 << key_frames_permille;
+    RTC_HISTOGRAMS_COUNTS_1000(
+        idx,
+        uma_prefix + ".KeyFramesReceivedInPermille" + uma_experiment_suffix,
+        key_frames_permille);
+    LOG(LS_INFO) << uma_prefix << ".KeyFramesReceivedInPermille"
+                 << uma_experiment_suffix << " " << key_frames_permille;
   }
 
   int qp = qp_counters_.vp8.Avg(kMinRequiredSamples);
   if (qp != -1) {
-    RTC_HISTOGRAM_COUNTS_200("WebRTC.Video.Decoded.Vp8.Qp", qp);
-    LOG(LS_INFO) << "WebRTC.Video.Decoded.Vp8.Qp " << qp;
+    RTC_HISTOGRAMS_COUNTS_200(
+        idx, uma_prefix + ".Decoded.Vp8.Qp" + uma_experiment_suffix, qp);
+    LOG(LS_INFO) << uma_prefix << ".Decoded.Vp8.Qp" << uma_experiment_suffix
+                 << " " << qp;
   }
   int decode_ms = decode_time_counter_.Avg(kMinRequiredSamples);
   if (decode_ms != -1) {
     RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.DecodeTimeInMs", decode_ms);
     LOG(LS_INFO) << "WebRTC.Video.DecodeTimeInMs " << decode_ms;
   }
   int jb_delay_ms = jitter_buffer_delay_counter_.Avg(kMinRequiredSamples);
   if (jb_delay_ms != -1) {
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.JitterBufferDelayInMs",
                                jb_delay_ms);
     LOG(LS_INFO) << "WebRTC.Video.JitterBufferDelayInMs " << jb_delay_ms;
   }
 
   int target_delay_ms = target_delay_counter_.Avg(kMinRequiredSamples);
   if (target_delay_ms != -1) {
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.TargetDelayInMs", target_delay_ms);
     LOG(LS_INFO) << "WebRTC.Video.TargetDelayInMs " << target_delay_ms;
   }
   int current_delay_ms = current_delay_counter_.Avg(kMinRequiredSamples);
   if (current_delay_ms != -1) {
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.CurrentDelayInMs",
                                current_delay_ms);
     LOG(LS_INFO) << "WebRTC.Video.CurrentDelayInMs " << current_delay_ms;
   }
   int delay_ms = delay_counter_.Avg(kMinRequiredSamples);
   if (delay_ms != -1)
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.OnewayDelayInMs", delay_ms);
 
-  int e2e_delay_ms_video = e2e_delay_counter_video_.Avg(kMinRequiredSamples);
-  if (e2e_delay_ms_video != -1) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.EndToEndDelayInMs",
-                               e2e_delay_ms_video);
-    LOG(LS_INFO) << "WebRTC.Video.EndToEndDelayInMs " << e2e_delay_ms_video;
-  }
-
-  int e2e_delay_ms_screenshare =
-      e2e_delay_counter_screenshare_.Avg(kMinRequiredSamples);
-  if (e2e_delay_ms_screenshare != -1) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.Screenshare.EndToEndDelayInMs",
-                               e2e_delay_ms_screenshare);
-  }
-
-  int e2e_delay_max_ms_video = e2e_delay_max_ms_video_;
-  if (e2e_delay_max_ms_video != -1) {
-    RTC_HISTOGRAM_COUNTS_100000("WebRTC.Video.EndToEndDelayMaxInMs",
-                                e2e_delay_max_ms_video);
-  }
-
-  int e2e_delay_max_ms_screenshare = e2e_delay_max_ms_screenshare_;
-  if (e2e_delay_max_ms_screenshare != -1) {
-    RTC_HISTOGRAM_COUNTS_100000("WebRTC.Video.Screenshare.EndToEndDelayMaxInMs",
-                                e2e_delay_max_ms_screenshare);
-  }
-
-  int interframe_delay_ms_screenshare =
-      interframe_delay_counter_screenshare_.Avg(kMinRequiredSamples);
-  if (interframe_delay_ms_screenshare != -1) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.Screenshare.InterframeDelayInMs",
-                               interframe_delay_ms_screenshare);
-    RTC_DCHECK_GE(interframe_delay_max_ms_screenshare_,
-                  interframe_delay_ms_screenshare);
-    RTC_HISTOGRAM_COUNTS_10000(
-        "WebRTC.Video.Screenshare.InterframeDelayMaxInMs",
-        interframe_delay_max_ms_screenshare_);
-  }
-
-  int interframe_delay_ms_video =
-      interframe_delay_counter_video_.Avg(kMinRequiredSamples);
-  if (interframe_delay_ms_video != -1) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.InterframeDelayInMs",
-                               interframe_delay_ms_video);
-    RTC_DCHECK_GE(interframe_delay_max_ms_video_, interframe_delay_ms_video);
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.InterframeDelayMaxInMs",
-                               interframe_delay_max_ms_video_);
-  }
-
   StreamDataCounters rtp = stats_.rtp_stats;
   StreamDataCounters rtx;
   for (auto it : rtx_stats_)
     rtx.Add(it.second);
   StreamDataCounters rtp_rtx = rtp;
   rtp_rtx.Add(rtx);
   int64_t elapsed_sec =
       rtp_rtx.TimeSinceFirstPacketInMs(clock_->TimeInMilliseconds()) / 1000;
   if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
     RTC_HISTOGRAM_COUNTS_10000(
         "WebRTC.Video.BitrateReceivedInKbps",
         static_cast<int>(rtp_rtx.transmitted.TotalBytes() * 8 / elapsed_sec /
                          1000));
-    RTC_HISTOGRAM_COUNTS_10000(
-        "WebRTC.Video.MediaBitrateReceivedInKbps",
-        static_cast<int>(rtp.MediaPayloadBytes() * 8 / elapsed_sec / 1000));
+    int media_bitrate_kbs =
+        static_cast<int>(rtp.MediaPayloadBytes() * 8 / elapsed_sec / 1000);
+    RTC_HISTOGRAMS_COUNTS_10000(
+        idx, uma_prefix + ".MediaBitrateReceivedInKbps" + uma_experiment_suffix,
+        media_bitrate_kbs);
+    LOG(LS_INFO) << uma_prefix << ".MediaBitrateReceivedInKbps"
+                 << uma_experiment_suffix << " " << media_bitrate_kbs;
     RTC_HISTOGRAM_COUNTS_10000(
         "WebRTC.Video.PaddingBitrateReceivedInKbps",
         static_cast<int>(rtp_rtx.transmitted.padding_bytes * 8 / elapsed_sec /
                          1000));
     RTC_HISTOGRAM_COUNTS_10000(
         "WebRTC.Video.RetransmittedBitrateReceivedInKbps",
         static_cast<int>(rtp_rtx.retransmitted.TotalBytes() * 8 / elapsed_sec /
                          1000));
     if (!rtx_stats_.empty()) {
       RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.RtxBitrateReceivedInKbps",
@@ skipping 256 matching lines @@
   }
   if (total_bytes > last_total_bytes)
     total_byte_tracker_.AddSamples(total_bytes - last_total_bytes);
 }
 
 void ReceiveStatisticsProxy::OnDecodedFrame(rtc::Optional<uint8_t> qp,
                                             VideoContentType content_type) {
   uint64_t now = clock_->TimeInMilliseconds();
 
   rtc::CritScope lock(&crit_);
+
+  ContentSpecificStats* content_specific_stats =
+      &content_specific_stats_[content_type];
   ++stats_.frames_decoded;
   if (qp) {
     if (!stats_.qp_sum) {
       if (stats_.frames_decoded != 1) {
         LOG(LS_WARNING)
             << "Frames decoded was not 1 when first qp value was received.";
         stats_.frames_decoded = 1;
       }
       stats_.qp_sum = rtc::Optional<uint64_t>(0);
     }
     *stats_.qp_sum += *qp;
+    content_specific_stats->qp_counter.Add(*qp);
   } else if (stats_.qp_sum) {
     LOG(LS_WARNING)
         << "QP sum was already set and no QP was given for a frame.";
     stats_.qp_sum = rtc::Optional<uint64_t>();
   }
   last_content_type_ = content_type;
   decode_fps_estimator_.Update(1, now);
   if (last_decoded_frame_time_ms_) {
     int64_t interframe_delay_ms = now - *last_decoded_frame_time_ms_;
     RTC_DCHECK_GE(interframe_delay_ms, 0);
     interframe_delay_max_moving_.Add(interframe_delay_ms, now);
-    if (last_content_type_ == VideoContentType::SCREENSHARE) {
-      interframe_delay_counter_screenshare_.Add(interframe_delay_ms);
-      if (interframe_delay_max_ms_screenshare_ < interframe_delay_ms) {
-        interframe_delay_max_ms_screenshare_ = interframe_delay_ms;
-      }
-    } else {
-      interframe_delay_counter_video_.Add(interframe_delay_ms);
-      if (interframe_delay_max_ms_video_ < interframe_delay_ms) {
-        interframe_delay_max_ms_video_ = interframe_delay_ms;
-      }
-    }
+    content_specific_stats->interframe_delay_counter.Add(interframe_delay_ms);
+    content_specific_stats->flow_duration_ms += interframe_delay_ms;
+    interframe_delay_counter.Add(interframe_delay_ms);
   }
   last_decoded_frame_time_ms_.emplace(now);
 }
 
 void ReceiveStatisticsProxy::OnRenderedFrame(const VideoFrame& frame) {
   int width = frame.width();
   int height = frame.height();
   RTC_DCHECK_GT(width, 0);
   RTC_DCHECK_GT(height, 0);
   uint64_t now = clock_->TimeInMilliseconds();
-
   rtc::CritScope lock(&crit_);
+  ContentSpecificStats* content_specific_stats =
+      &content_specific_stats_[last_content_type_];
   renders_fps_estimator_.Update(1, now);
   ++stats_.frames_rendered;
   stats_.width = width;
   stats_.height = height;
   render_width_counter_.Add(width);
   render_height_counter_.Add(height);
   render_fps_tracker_.AddSamples(1);
   render_pixel_tracker_.AddSamples(sqrt(width * height));
+  content_specific_stats->received_width.Add(width);
+  content_specific_stats->received_height.Add(height);
 
   if (frame.ntp_time_ms() > 0) {
     int64_t delay_ms = clock_->CurrentNtpInMilliseconds() - frame.ntp_time_ms();
     if (delay_ms >= 0) {
-      if (last_content_type_ == VideoContentType::SCREENSHARE) {
-        e2e_delay_max_ms_screenshare_ =
-            std::max(delay_ms, e2e_delay_max_ms_screenshare_);
-        e2e_delay_counter_screenshare_.Add(delay_ms);
-      } else {
-        e2e_delay_max_ms_video_ = std::max(delay_ms, e2e_delay_max_ms_video_);
-        e2e_delay_counter_video_.Add(delay_ms);
-      }
+      content_specific_stats->e2e_delay_counter.Add(delay_ms);
+      e2e_delay_counter.Add(delay_ms);
     }
   }
 }
 
 void ReceiveStatisticsProxy::OnSyncOffsetUpdated(int64_t sync_offset_ms,
                                                  double estimated_freq_khz) {
   rtc::CritScope lock(&crit_);
   sync_offset_counter_.Add(std::abs(sync_offset_ms));
   stats_.sync_offset_ms = sync_offset_ms;
 
@@ skipping 11 matching lines @@
 }
 
 void ReceiveStatisticsProxy::OnCompleteFrame(bool is_keyframe,
                                              size_t size_bytes) {
   rtc::CritScope lock(&crit_);
   if (is_keyframe)
     ++stats_.frame_counts.key_frames;
   else
     ++stats_.frame_counts.delta_frames;
 
+  // Todo(ilnik): May be incorrect for the first frame of a new content type
+  // stream. Leads to a bit incorrect |total_media_bytes| count.
+  ContentSpecificStats* content_specific_stats =
+      &content_specific_stats_[last_content_type_];
+
+  content_specific_stats->total_media_bytes += size_bytes;
+
   int64_t now_ms = clock_->TimeInMilliseconds();
   frame_window_.insert(std::make_pair(now_ms, size_bytes));
   UpdateFramerate(now_ms);
 }
 
 void ReceiveStatisticsProxy::OnFrameCountsUpdated(
     const FrameCounts& frame_counts) {
   rtc::CritScope lock(&crit_);
   stats_.frame_counts = frame_counts;
 }
@@ skipping 20 matching lines @@
   // TODO(sprang): Figure out any other state that should be reset.
 
   rtc::CritScope lock(&crit_);
   // Don't report inter-frame delay if stream was paused.
   last_decoded_frame_time_ms_.reset();
 }
 
 void ReceiveStatisticsProxy::SampleCounter::Add(int sample) {
   sum += sample;
   ++num_samples;
+  if (!max || *max < sample) {
+    max.emplace(sample);
+  }
 }
 
 int ReceiveStatisticsProxy::SampleCounter::Avg(
     int64_t min_required_samples) const {
   if (num_samples < min_required_samples || num_samples == 0)
     return -1;
   return static_cast<int>(sum / num_samples);
 }
 
+int ReceiveStatisticsProxy::SampleCounter::Max() const {
+  if (!max) {
+    return -1;
+  } else {
+    return *max;
+  }
+}
+
 void ReceiveStatisticsProxy::SampleCounter::Reset() {
   num_samples = 0;
   sum = 0;
+  max.reset();
 }
 
 void ReceiveStatisticsProxy::OnRttUpdate(int64_t avg_rtt_ms,
                                          int64_t max_rtt_ms) {
   rtc::CritScope lock(&crit_);
   avg_rtt_ms_ = avg_rtt_ms;
 }
 
 }  // namespace webrtc