Properly report number of quality downscales in stats.

webrtc/video/send_statistics_proxy_unittest.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 13 matching lines @@
 const uint32_t kFirstSsrc = 17;
 const uint32_t kSecondSsrc = 42;
 const uint32_t kFirstRtxSsrc = 18;
 const uint32_t kSecondRtxSsrc = 43;
 const uint32_t kFlexFecSsrc = 55;
 const int kFpsPeriodicIntervalMs = 2000;
 const int kWidth = 640;
 const int kHeight = 480;
 const int kQpIdx0 = 21;
 const int kQpIdx1 = 39;
+const CodecSpecificInfo kDefaultCodecInfo = []() {
+  CodecSpecificInfo codec_info;
+  codec_info.codecType = kVideoCodecVP8;
+  codec_info.codecSpecific.VP8.simulcastIdx = 0;
+  return codec_info;
+}();
 }  // namespace
 
 class SendStatisticsProxyTest : public ::testing::Test {
  public:
   SendStatisticsProxyTest()
       : fake_clock_(1234), config_(GetTestConfig()), avg_delay_ms_(0),
         max_delay_ms_(0) {}
   virtual ~SendStatisticsProxyTest() {}
 
  protected:
@@ skipping 608 matching lines @@
   EXPECT_EQ(1, metrics::NumSamples(
                    "WebRTC.Video.BandwidthLimitedResolutionsDisabled"));
   EXPECT_EQ(
       1, metrics::NumEvents("WebRTC.Video.BandwidthLimitedResolutionsDisabled",
                             kResolutionsDisabled));
 }
 
 TEST_F(SendStatisticsProxyTest,
        QualityLimitedHistogramsNotUpdatedWhenDisabled) {
   EncodedImage encoded_image;
-  // encoded_image.adapt_reason_.quality_resolution_downscales disabled by
-  // default: -1
+  statistics_proxy_->SetResolutionRestrictionStats(false /* scaling_enabled */,
+                                                   0, 0);
   for (int i = 0; i < SendStatisticsProxy::kMinRequiredMetricsSamples; ++i)
-    statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
+    statistics_proxy_->OnSendEncodedImage(encoded_image, &kDefaultCodecInfo);
 
   // Histograms are updated when the statistics_proxy_ is deleted.
   statistics_proxy_.reset();
+  EXPECT_EQ(
+      0, metrics::NumSamples("WebRTC.Video.QualityLimitedResolutionInPercent"));
+  EXPECT_EQ(0, metrics::NumSamples(
+                   "WebRTC.Video.QualityLimitedResolutionDownscales"));
+}
+
+TEST_F(SendStatisticsProxyTest,
+       QualityLimitedHistogramsNotUpdatedForAdditionalSimulcastStreams) {
+  EncodedImage encoded_image;
+  // Quality limited histograms are only enabled for stream 0
+  // in simulcast;
+  CodecSpecificInfo codec_info = kDefaultCodecInfo;
+  codec_info.codecSpecific.VP8.simulcastIdx = 1;
+  for (int i = 0; i < SendStatisticsProxy::kMinRequiredMetricsSamples; ++i)
+    statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
+
+  // Histograms are updated when the statistics_proxy_ is deleted.
+  statistics_proxy_.reset();
   EXPECT_EQ(
       0, metrics::NumSamples("WebRTC.Video.QualityLimitedResolutionInPercent"));
   EXPECT_EQ(0, metrics::NumSamples(
                    "WebRTC.Video.QualityLimitedResolutionDownscales"));
 }
 
 TEST_F(SendStatisticsProxyTest,
        QualityLimitedHistogramsUpdatedWhenEnabled_NoResolutionDownscale) {
-  const int kDownscales = 0;
   EncodedImage encoded_image;
-  encoded_image.adapt_reason_.quality_resolution_downscales = kDownscales;
   for (int i = 0; i < SendStatisticsProxy::kMinRequiredMetricsSamples; ++i)
-    statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
+    statistics_proxy_->OnSendEncodedImage(encoded_image, &kDefaultCodecInfo);
 
   // Histograms are updated when the statistics_proxy_ is deleted.
   statistics_proxy_.reset();
   EXPECT_EQ(
       1, metrics::NumSamples("WebRTC.Video.QualityLimitedResolutionInPercent"));
   EXPECT_EQ(1, metrics::NumEvents(
                    "WebRTC.Video.QualityLimitedResolutionInPercent", 0));
   // No resolution downscale.
   EXPECT_EQ(0, metrics::NumSamples(
                    "WebRTC.Video.QualityLimitedResolutionDownscales"));
 }
 
 TEST_F(SendStatisticsProxyTest,
        QualityLimitedHistogramsUpdatedWhenEnabled_TwoResolutionDownscales) {
   const int kDownscales = 2;
   EncodedImage encoded_image;
-  encoded_image.adapt_reason_.quality_resolution_downscales = kDownscales;
+  statistics_proxy_->OnQualityRestrictedResolutionChanged(kDownscales);
   for (int i = 0; i < SendStatisticsProxy::kMinRequiredMetricsSamples; ++i)
-    statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
-
+    statistics_proxy_->OnSendEncodedImage(encoded_image, &kDefaultCodecInfo);
   // Histograms are updated when the statistics_proxy_ is deleted.
   statistics_proxy_.reset();
   EXPECT_EQ(
       1, metrics::NumSamples("WebRTC.Video.QualityLimitedResolutionInPercent"));
   EXPECT_EQ(1, metrics::NumEvents(
                    "WebRTC.Video.QualityLimitedResolutionInPercent", 100));
   // Resolution downscales.
   EXPECT_EQ(1, metrics::NumSamples(
                    "WebRTC.Video.QualityLimitedResolutionDownscales"));
   EXPECT_EQ(
       1, metrics::NumEvents("WebRTC.Video.QualityLimitedResolutionDownscales",
                             kDownscales));
 }
 
 TEST_F(SendStatisticsProxyTest, GetStatsReportsBandwidthLimitedResolution) {
   // Initially false.
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
   // No resolution scale by default.
   EncodedImage encoded_image;
   statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
-  // Resolution not scaled.
+
+  // Simulcast disabled resolutions
+  encoded_image.adapt_reason_.bw_resolutions_disabled = 1;
+  statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
+  EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_resolution);
+
   encoded_image.adapt_reason_.bw_resolutions_disabled = 0;
   statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
-  // Resolution scaled due to bandwidth.
-  encoded_image.adapt_reason_.bw_resolutions_disabled = 1;
+
+  // Resolution scaled due to quality.
+  statistics_proxy_->OnQualityRestrictedResolutionChanged(1);
   statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
   EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_resolution);
 }
 
 TEST_F(SendStatisticsProxyTest, NoSubstreams) {
   uint32_t excluded_ssrc =
       std::max(
           *std::max_element(config_.rtp.ssrcs.begin(), config_.rtp.ssrcs.end()),
           *std::max_element(config_.rtp.rtx.ssrcs.begin(),
                             config_.rtp.rtx.ssrcs.end())) +
@@ skipping 424 matching lines @@
 
   EXPECT_EQ(
       1, metrics::NumSamples("WebRTC.Video.Screenshare.FecBitrateSentInKbps"));
   EXPECT_EQ(1, metrics::NumEvents(
                    "WebRTC.Video.Screenshare.FecBitrateSentInKbps",
                    static_cast<int>((counters.fec.TotalBytes() * 2 * 8) /
                                     metrics::kMinRunTimeInSeconds / 1000)));
 }
 
 }  // namespace webrtc