Rename ViEEncoder to VideoStreamEncoder.

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 350 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, GetCpuAdaptationStats) {
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
   cpu_counts.fps = 1;
   cpu_counts.resolution = 0;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
   cpu_counts.fps = 0;
   cpu_counts.resolution = 1;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_resolution);
   cpu_counts.fps = 1;
   cpu_counts.resolution = -1;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
   cpu_counts.fps = -1;
   cpu_counts.resolution = -1;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
 }
 
 TEST_F(SendStatisticsProxyTest, GetQualityAdaptationStats) {
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
   quality_counts.fps = 1;
   quality_counts.resolution = 0;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
   quality_counts.fps = 0;
   quality_counts.resolution = 1;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_framerate);
   EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_resolution);
   quality_counts.fps = 1;
   quality_counts.resolution = -1;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
   quality_counts.fps = -1;
   quality_counts.resolution = -1;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
 }
 
 TEST_F(SendStatisticsProxyTest, GetStatsReportsCpuAdaptChanges) {
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   EXPECT_EQ(0, statistics_proxy_->GetStats().number_of_cpu_adapt_changes);
 
   cpu_counts.resolution = 1;
   statistics_proxy_->OnCpuAdaptationChanged(cpu_counts, quality_counts);
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_resolution);
   EXPECT_EQ(1, statistics_proxy_->GetStats().number_of_cpu_adapt_changes);
 
   cpu_counts.resolution = 2;
   statistics_proxy_->OnCpuAdaptationChanged(cpu_counts, quality_counts);
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_resolution);
   EXPECT_EQ(2, statistics_proxy_->GetStats().number_of_cpu_adapt_changes);
   EXPECT_EQ(0, statistics_proxy_->GetStats().number_of_quality_adapt_changes);
 }
 
 TEST_F(SendStatisticsProxyTest, GetStatsReportsQualityAdaptChanges) {
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   EXPECT_EQ(0, statistics_proxy_->GetStats().number_of_quality_adapt_changes);
 
   quality_counts.fps = 1;
   statistics_proxy_->OnQualityAdaptationChanged(cpu_counts, quality_counts);
   EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
   EXPECT_EQ(1, statistics_proxy_->GetStats().number_of_quality_adapt_changes);
 
   quality_counts.fps = 0;
   statistics_proxy_->OnQualityAdaptationChanged(cpu_counts, quality_counts);
@@ skipping 11 matching lines @@
   statistics_proxy_.reset();
   EXPECT_EQ(0, metrics::NumSamples("WebRTC.Video.AdaptChangesPerMinute.Cpu"));
   EXPECT_EQ(0,
             metrics::NumSamples("WebRTC.Video.AdaptChangesPerMinute.Quality"));
 }
 
 TEST_F(SendStatisticsProxyTest, AdaptChangesNotReported_MinRuntimeNotPassed) {
   // First RTP packet sent.
   UpdateDataCounters(kFirstSsrc);
   // Enable adaptation.
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   // Min runtime has not passed.
   fake_clock_.AdvanceTimeMilliseconds(metrics::kMinRunTimeInSeconds * 1000 - 1);
   statistics_proxy_.reset();
   EXPECT_EQ(0, metrics::NumSamples("WebRTC.Video.AdaptChangesPerMinute.Cpu"));
   EXPECT_EQ(0,
             metrics::NumSamples("WebRTC.Video.AdaptChangesPerMinute.Quality"));
 }
 
 TEST_F(SendStatisticsProxyTest, ZeroAdaptChangesReported) {
   // First RTP packet sent.
   UpdateDataCounters(kFirstSsrc);
   // Enable adaptation.
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   // Min runtime has passed.
   fake_clock_.AdvanceTimeMilliseconds(metrics::kMinRunTimeInSeconds * 1000);
   statistics_proxy_.reset();
   EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.AdaptChangesPerMinute.Cpu"));
   EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.AdaptChangesPerMinute.Cpu", 0));
   EXPECT_EQ(1,
             metrics::NumSamples("WebRTC.Video.AdaptChangesPerMinute.Quality"));
   EXPECT_EQ(
       1, metrics::NumEvents("WebRTC.Video.AdaptChangesPerMinute.Quality", 0));
 }
 
 TEST_F(SendStatisticsProxyTest, CpuAdaptChangesReported) {
   // First RTP packet sent.
   UpdateDataCounters(kFirstSsrc);
   // Enable adaptation.
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   // Adapt changes: 1, elapsed time: 10 sec => 6 per minute.
   statistics_proxy_->OnCpuAdaptationChanged(cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(10000);
   statistics_proxy_.reset();
   EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.AdaptChangesPerMinute.Cpu"));
   EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.AdaptChangesPerMinute.Cpu", 6));
 }
 
 TEST_F(SendStatisticsProxyTest, AdaptChangesStatsExcludesDisabledTime) {
   // First RTP packet sent.
   UpdateDataCounters(kFirstSsrc);
 
   // Disable quality adaptation.
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   quality_counts.fps = -1;
   quality_counts.resolution = -1;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(10000);
 
   // Enable quality adaptation.
   // Adapt changes: 2, elapsed time: 20 sec.
   quality_counts.fps = 0;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(5000);
@@ skipping 46 matching lines @@
   EXPECT_EQ(0, metrics::NumSamples("WebRTC.Video.AdaptChangesPerMinute.Cpu"));
   EXPECT_EQ(0,
             metrics::NumSamples("WebRTC.Video.AdaptChangesPerMinute.Quality"));
 }
 
 TEST_F(SendStatisticsProxyTest, QualityAdaptChangesStatsExcludesSuspendedTime) {
   // First RTP packet sent.
   UpdateDataCounters(kFirstSsrc);
 
   // Enable adaptation.
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   // Adapt changes: 2, elapsed time: 20 sec.
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(20000);
   statistics_proxy_->OnQualityAdaptationChanged(cpu_counts, quality_counts);
   statistics_proxy_->OnQualityAdaptationChanged(cpu_counts, quality_counts);
 
   // Suspend and resume video.
   statistics_proxy_->OnSuspendChange(true);
   fake_clock_.AdvanceTimeMilliseconds(30000);
   statistics_proxy_->OnSuspendChange(false);
@@ skipping 12 matching lines @@
 
 TEST_F(SendStatisticsProxyTest, CpuAdaptChangesStatsExcludesSuspendedTime) {
   // First RTP packet sent.
   UpdateDataCounters(kFirstSsrc);
 
   // Video not suspended.
   statistics_proxy_->OnSuspendChange(false);
   fake_clock_.AdvanceTimeMilliseconds(30000);
 
   // Enable adaptation.
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   // Adapt changes: 1, elapsed time: 20 sec.
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(10000);
   statistics_proxy_->OnCpuAdaptationChanged(cpu_counts, quality_counts);
 
   // Video not suspended, stats time already started.
   statistics_proxy_->OnSuspendChange(false);
   fake_clock_.AdvanceTimeMilliseconds(10000);
 
   // Disable adaptation.
@@ skipping 23 matching lines @@
 }
 
 TEST_F(SendStatisticsProxyTest, AdaptChangesStatsNotStartedIfVideoSuspended) {
   // First RTP packet sent.
   UpdateDataCounters(kFirstSsrc);
 
   // Video suspended.
   statistics_proxy_->OnSuspendChange(true);
 
   // Enable adaptation, stats time not started when suspended.
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(10000);
 
   // Resume video, stats time started.
   // Adapt changes: 1, elapsed time: 10 sec.
   statistics_proxy_->OnSuspendChange(false);
   fake_clock_.AdvanceTimeMilliseconds(10000);
   statistics_proxy_->OnCpuAdaptationChanged(cpu_counts, quality_counts);
 
   // Adapt changes: 1, elapsed time: 10 sec => 6 per minute.
   statistics_proxy_.reset();
   EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.AdaptChangesPerMinute.Cpu"));
   EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.AdaptChangesPerMinute.Cpu", 6));
 }
 
 TEST_F(SendStatisticsProxyTest, AdaptChangesStatsRestartsOnFirstSentPacket) {
   // Send first packet, adaptation enabled.
   // Elapsed time before first packet is sent should be excluded.
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(10000);
   UpdateDataCounters(kFirstSsrc);
 
   // Adapt changes: 1, elapsed time: 10 sec.
   fake_clock_.AdvanceTimeMilliseconds(10000);
   statistics_proxy_->OnQualityAdaptationChanged(cpu_counts, quality_counts);
   UpdateDataCounters(kFirstSsrc);
 
   // Adapt changes: 1, elapsed time: 10 sec => 6 per minute.
   statistics_proxy_.reset();
   EXPECT_EQ(1,
             metrics::NumSamples("WebRTC.Video.AdaptChangesPerMinute.Quality"));
   EXPECT_EQ(
       1, metrics::NumEvents("WebRTC.Video.AdaptChangesPerMinute.Quality", 6));
 }
 
 TEST_F(SendStatisticsProxyTest, AdaptChangesStatsStartedAfterFirstSentPacket) {
   // Enable and disable adaptation.
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(60000);
   cpu_counts.fps = -1;
   cpu_counts.resolution = -1;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
 
   // Send first packet, scaling disabled.
   // Elapsed time before first packet is sent should be excluded.
   UpdateDataCounters(kFirstSsrc);
   fake_clock_.AdvanceTimeMilliseconds(60000);
@@ skipping 10 matching lines @@
 
   // Adapt changes: 1, elapsed time: 20 sec => 3 per minute.
   statistics_proxy_.reset();
   EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.AdaptChangesPerMinute.Cpu"));
   EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.AdaptChangesPerMinute.Cpu", 3));
 }
 
 TEST_F(SendStatisticsProxyTest, AdaptChangesReportedAfterContentSwitch) {
   // First RTP packet sent, cpu adaptation enabled.
   UpdateDataCounters(kFirstSsrc);
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   quality_counts.fps = -1;
   quality_counts.resolution = -1;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
 
   // Adapt changes: 2, elapsed time: 15 sec => 8 per minute.
   statistics_proxy_->OnCpuAdaptationChanged(cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(6000);
   statistics_proxy_->OnCpuAdaptationChanged(cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(9000);
 
@@ skipping 139 matching lines @@
     encoded_image._timeStamp = i + 1;
     statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
   }
   // Suspended time interval should not affect the framerate.
   statistics_proxy_.reset();
   EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.SentFramesPerSecond"));
   EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.SentFramesPerSecond", kFps));
 }
 
 TEST_F(SendStatisticsProxyTest, CpuLimitedHistogramNotUpdatedWhenDisabled) {
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   cpu_counts.resolution = -1;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
 
   for (int i = 0; i < SendStatisticsProxy::kMinRequiredMetricsSamples; ++i)
     statistics_proxy_->OnIncomingFrame(kWidth, kHeight);
 
   statistics_proxy_.reset();
   EXPECT_EQ(0,
             metrics::NumSamples("WebRTC.Video.CpuLimitedResolutionInPercent"));
 }
 
 TEST_F(SendStatisticsProxyTest, CpuLimitedHistogramUpdated) {
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   cpu_counts.resolution = 0;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
 
   for (int i = 0; i < SendStatisticsProxy::kMinRequiredMetricsSamples; ++i)
     statistics_proxy_->OnIncomingFrame(kWidth, kHeight);
 
   cpu_counts.resolution = 1;
   statistics_proxy_->OnCpuAdaptationChanged(cpu_counts, quality_counts);
 
   for (int i = 0; i < SendStatisticsProxy::kMinRequiredMetricsSamples; ++i)
@@ skipping 276 matching lines @@
   // Resolutions disabled.
   EXPECT_EQ(1, metrics::NumSamples(
                    "WebRTC.Video.BandwidthLimitedResolutionsDisabled"));
   EXPECT_EQ(
       1, metrics::NumEvents("WebRTC.Video.BandwidthLimitedResolutionsDisabled",
                             kResolutionsDisabled));
 }
 
 TEST_F(SendStatisticsProxyTest,
        QualityLimitedHistogramsNotUpdatedWhenDisabled) {
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   quality_counts.resolution = -1;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   EncodedImage encoded_image;
   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"));
 }
 
 TEST_F(SendStatisticsProxyTest,
        QualityLimitedHistogramsUpdatedWhenEnabled_NoResolutionDownscale) {
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   quality_counts.resolution = 0;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   EncodedImage encoded_image;
   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(
       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;
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   quality_counts.resolution = kDownscales;
   statistics_proxy_->SetAdaptationStats(cpu_counts, quality_counts);
   EncodedImage encoded_image;
   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(
       1, metrics::NumSamples("WebRTC.Video.QualityLimitedResolutionInPercent"));
   EXPECT_EQ(1, metrics::NumEvents(
@@ skipping 17 matching lines @@
   // 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 quality.
-  ViEEncoder::AdaptCounts cpu_counts;
-  ViEEncoder::AdaptCounts quality_counts;
+  VideoStreamEncoder::AdaptCounts cpu_counts;
+  VideoStreamEncoder::AdaptCounts quality_counts;
   quality_counts.resolution = 1;
   statistics_proxy_->OnQualityAdaptationChanged(cpu_counts, quality_counts);
   statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
   EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_resolution);
 }
 
 TEST_F(SendStatisticsProxyTest, GetStatsReportsTargetMediaBitrate) {
   // Initially zero.
   EXPECT_EQ(0, statistics_proxy_->GetStats().target_media_bitrate_bps);
 
@@ skipping 483 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