Do not report quality limited resolution stats when quality scaler is disabled.

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 349 matching lines @@
 
 TEST_F(SendStatisticsProxyTest, OnSendEncodedImageWithoutQpQpSumWontExist) {
   EncodedImage encoded_image;
   CodecSpecificInfo codec_info;
   encoded_image.qp_ = -1;
   EXPECT_EQ(rtc::Optional<uint64_t>(), statistics_proxy_->GetStats().qp_sum);
   statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
   EXPECT_EQ(rtc::Optional<uint64_t>(), statistics_proxy_->GetStats().qp_sum);
 }
 
+TEST_F(SendStatisticsProxyTest, SetCpuRestrictionUpdatesStats) {
+  const bool kQualityScalingEnabled = true;
+  const bool kCpuRestricted = true;
+  const int kQualityDownscales = 0;
+  EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
+  EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
+
+  // Cpu restricted and cpu scaling enabled, stats should be cpu limited.
+  statistics_proxy_->SetResolutionRestrictionStats(
+      true,  // cpu_scaling_enabled
+      kQualityScalingEnabled, kCpuRestricted, kQualityDownscales);
+  EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_resolution);
+  EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
+
+  // Cpu restricted but cpu scaling disabled, stats should not be cpu limited.
+  statistics_proxy_->SetResolutionRestrictionStats(
+      false,  // cpu_scaling_enabled
+      kQualityScalingEnabled, kCpuRestricted, kQualityDownscales);
+  EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
+  EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
+}
+
+TEST_F(SendStatisticsProxyTest, SetQualityRestrictionUpdatesStats) {
+  const bool kCpuScalingEnabled = true;
+  const bool kCpuRestricted = false;
+  const int kQualityDownscales = 1;
+  EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
+  EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
+
+  // Quality downscaled and quality scaling enabled, stats should be bw limited.
+  statistics_proxy_->SetResolutionRestrictionStats(
+      kCpuScalingEnabled,
+      true,  // quality_scaling_enabled
+      kCpuRestricted, kQualityDownscales);
+  EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_resolution);
+  EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
+
+  // Quality downscaled but quality scaling disabled, stats should not be bw
+  // limited.
+  statistics_proxy_->SetResolutionRestrictionStats(
+      kCpuScalingEnabled,
+      false,  // quality_scaling_enabled
+      kCpuRestricted, kQualityDownscales);
+  EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
+  EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
+}
+
 TEST_F(SendStatisticsProxyTest, SwitchContentTypeUpdatesHistograms) {
   for (int i = 0; i < SendStatisticsProxy::kMinRequiredMetricsSamples; ++i)
     statistics_proxy_->OnIncomingFrame(kWidth, kHeight);
 
   // No switch, stats should not be updated.
   VideoEncoderConfig config;
   config.content_type = VideoEncoderConfig::ContentType::kRealtimeVideo;
   statistics_proxy_->OnEncoderReconfigured(config, 50);
   EXPECT_EQ(0, metrics::NumSamples("WebRTC.Video.InputWidthInPixels"));
 
@@ skipping 393 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;
-  statistics_proxy_->SetResolutionRestrictionStats(false /* scaling_enabled */,
-                                                   0, 0);
+  statistics_proxy_->SetResolutionRestrictionStats(
+      true /* cpu_scaling_enabled */, false /* quality_scaling_enabled */,
+      false, 0);
   for (int i = 0; i < SendStatisticsProxy::kMinRequiredMetricsSamples; ++i)
     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"));
 }
@@ skipping 549 matching lines @@
     fake_clock_.AdvanceTimeMilliseconds(kPeriodIntervalMs);
     proxy->DataCountersUpdated(counters, kFirstSsrc);
   }
 
   // FEC not enabled.
   statistics_proxy_.reset();
   EXPECT_EQ(0, metrics::NumSamples("WebRTC.Video.FecBitrateSentInKbps"));
 }
 
 }  // namespace webrtc