Add histogram stats for number of cpu/quality adapt changes per minute for sent video streams:

webrtc/video/send_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.
  */
 
@@ skipping 275 matching lines @@
     }
     int qp_h264 = it.second.h264.Avg(kMinRequiredMetricsSamples);
     if (qp_h264 != -1) {
       int spatial_idx = it.first;
       RTC_DCHECK_EQ(-1, spatial_idx);
       RTC_HISTOGRAMS_COUNTS_100(kIndex, uma_prefix_ + "Encoded.Qp.H264",
                                 qp_h264);
     }
   }
 
+  quality_scaling_timer_.Stop(clock_->TimeInMilliseconds());
+  int64_t elapsed_sec = quality_scaling_timer_.total_ms / 1000;
+  if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
+    int quality_changes = current_stats.number_of_quality_adapt_changes -
+                          start_stats_.number_of_quality_adapt_changes;
+    RTC_HISTOGRAMS_COUNTS_100(kIndex,
+                              uma_prefix_ + "AdaptChangesPerMinute.Quality",
+                              quality_changes * 60 / elapsed_sec);
+  }
+  cpu_scaling_timer_.Stop(clock_->TimeInMilliseconds());
+  elapsed_sec = cpu_scaling_timer_.total_ms / 1000;
+  if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
+    int cpu_changes = current_stats.number_of_cpu_adapt_changes -
+                      start_stats_.number_of_cpu_adapt_changes;
+    RTC_HISTOGRAMS_COUNTS_100(kIndex, uma_prefix_ + "AdaptChangesPerMinute.Cpu",
+                              cpu_changes * 60 / elapsed_sec);
+  }
+
   if (first_rtcp_stats_time_ms_ != -1) {
     int64_t elapsed_sec =
         (clock_->TimeInMilliseconds() - first_rtcp_stats_time_ms_) / 1000;
     if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
       int fraction_lost = report_block_stats_.FractionLostInPercent();
       if (fraction_lost != -1) {
         RTC_HISTOGRAMS_PERCENTAGE(
             kIndex, uma_prefix_ + "SentPacketsLostInPercent", fraction_lost);
       }
 
@@ skipping 371 matching lines @@
   uma_container_->input_fps_counter_.Add(1);
   uma_container_->input_width_counter_.Add(width);
   uma_container_->input_height_counter_.Add(height);
   uma_container_->cpu_limited_frame_counter_.Add(stats_.cpu_limited_resolution);
   TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.InputFrameRate",
       "frame_rate", round(
           uma_container_->input_frame_rate_tracker_.ComputeRate()),
       "ssrc", rtp_config_.ssrcs[0]);
 }
 
-void SendStatisticsProxy::SetCpuScalingStats(bool cpu_restricted_resolution) {
+void SendStatisticsProxy::SetCpuScalingStats(int num_cpu_downscales) {
   rtc::CritScope lock(&crit_);
-  stats_.cpu_limited_resolution = cpu_restricted_resolution;
+  stats_.cpu_limited_resolution = num_cpu_downscales > 0;
+
+  if (num_cpu_downscales >= 0) {
+    // Scaling enabled.
+    uma_container_->cpu_scaling_timer_.Start(clock_->TimeInMilliseconds());
+  } else {
+    uma_container_->cpu_scaling_timer_.Stop(clock_->TimeInMilliseconds());
+  }
 }
 
 void SendStatisticsProxy::SetQualityScalingStats(int num_quality_downscales) {
   rtc::CritScope lock(&crit_);
   quality_downscales_ = num_quality_downscales;
   stats_.bw_limited_resolution = quality_downscales_ > 0;
+
+  if (num_quality_downscales >= 0) {
+    // Scaling enabled.
+    uma_container_->quality_scaling_timer_.Start(clock_->TimeInMilliseconds());
+  } else {
+    uma_container_->quality_scaling_timer_.Stop(clock_->TimeInMilliseconds());
+  }
 }
 
 void SendStatisticsProxy::OnCpuRestrictedResolutionChanged(
     bool cpu_restricted_resolution) {
   rtc::CritScope lock(&crit_);
   stats_.cpu_limited_resolution = cpu_restricted_resolution;
   ++stats_.number_of_cpu_adapt_changes;
-  TRACE_EVENT_INSTANT0("webrtc_stats", "WebRTC.Video.AdaptationChanges");
+  TRACE_EVENT_INSTANT0("webrtc_stats", "WebRTC.Video.CpuAdaptationChanges");
 }
 
 void SendStatisticsProxy::OnQualityRestrictedResolutionChanged(
     int num_quality_downscales) {
   rtc::CritScope lock(&crit_);
   ++stats_.number_of_quality_adapt_changes;
   quality_downscales_ = num_quality_downscales;
   stats_.bw_limited_resolution = quality_downscales_ > 0;
 }
 
@@ skipping 40 matching lines @@
   VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
   RTC_DCHECK(stats) << "DataCountersUpdated reported for unknown ssrc " << ssrc;
 
   if (stats->is_flexfec) {
     // The same counters are reported for both the media ssrc and flexfec ssrc.
     // Bitrate stats are summed for all SSRCs. Use fec stats from media update.
     return;
   }
 
   stats->rtp_stats = counters;
-  if (uma_container_->first_rtp_stats_time_ms_ == -1)
-    uma_container_->first_rtp_stats_time_ms_ = clock_->TimeInMilliseconds();
+  if (uma_container_->first_rtp_stats_time_ms_ == -1) {
+    int64_t now_ms = clock_->TimeInMilliseconds();
+    uma_container_->first_rtp_stats_time_ms_ = now_ms;
+    uma_container_->cpu_scaling_timer_.Restart(now_ms);
+    uma_container_->quality_scaling_timer_.Restart(now_ms);
+  }
 
   uma_container_->total_byte_counter_.Set(counters.transmitted.TotalBytes(),
                                           ssrc);
   uma_container_->padding_byte_counter_.Set(counters.transmitted.padding_bytes,
                                             ssrc);
   uma_container_->retransmit_byte_counter_.Set(
       counters.retransmitted.TotalBytes(), ssrc);
   uma_container_->fec_byte_counter_.Set(counters.fec.TotalBytes(), ssrc);
   if (stats->is_rtx) {
     uma_container_->rtx_byte_counter_.Set(counters.transmitted.TotalBytes(),
@@ skipping 35 matching lines @@
   VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
   if (!stats)
     return;
   stats->avg_delay_ms = avg_delay_ms;
   stats->max_delay_ms = max_delay_ms;
 
   uma_container_->delay_counter_.Add(avg_delay_ms);
   uma_container_->max_delay_counter_.Add(max_delay_ms);
 }
 
+void SendStatisticsProxy::StatsTimer::Start(int64_t now_ms) {
+  if (start_ms == -1)
+    start_ms = now_ms;
+}
+
+void SendStatisticsProxy::StatsTimer::Stop(int64_t now_ms) {
+  if (start_ms != -1) {
+    total_ms += now_ms - start_ms;
+    start_ms = -1;
+  }
+}
+
+void SendStatisticsProxy::StatsTimer::Restart(int64_t now_ms) {
+  total_ms = 0;
+  if (start_ms != -1)
+    start_ms = now_ms;
+}
+
 void SendStatisticsProxy::SampleCounter::Add(int sample) {
   sum += sample;
   ++num_samples;
 }
 
 int SendStatisticsProxy::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 / 2)) / num_samples);
@@ skipping 21 matching lines @@
 }
 
 int SendStatisticsProxy::BoolSampleCounter::Fraction(
     int64_t min_required_samples,
     float multiplier) const {
   if (num_samples < min_required_samples || num_samples == 0)
     return -1;
   return static_cast<int>((sum * multiplier / num_samples) + 0.5f);
 }
 }  // namespace webrtc