Move usage of QualityScaler to ViEEncoder.

webrtc/video/overuse_frame_detector_unittest.cc

Index: webrtc/video/overuse_frame_detector_unittest.cc
diff --git a/webrtc/video/overuse_frame_detector_unittest.cc b/webrtc/video/overuse_frame_detector_unittest.cc
index 64747fa6845f01aedb3686a95cad98bf11d5334b..3966e47c0393df85313323b07570d16104425a1d 100644
--- a/webrtc/video/overuse_frame_detector_unittest.cc
+++ b/webrtc/video/overuse_frame_detector_unittest.cc
@@ -16,6 +16,7 @@
 #include "webrtc/test/gtest.h"
 #include "webrtc/video/overuse_frame_detector.h"
 #include "webrtc/video_frame.h"
+#include "webrtc/modules/video_coding/utility/quality_scaler.h"
 
 namespace webrtc {
 
@@ -29,24 +30,24 @@ namespace {
   const int kProcessTime5ms = 5;
 }  // namespace
 
-class MockCpuOveruseObserver : public CpuOveruseObserver {
+class MockCpuOveruseObserver : public ScalingInterface {
  public:
   MockCpuOveruseObserver() {}
   virtual ~MockCpuOveruseObserver() {}
 
-  MOCK_METHOD0(OveruseDetected, void());
-  MOCK_METHOD0(NormalUsage, void());
+  MOCK_METHOD0(ScaleUp, void());
+  MOCK_METHOD0(ScaleDown, void());
 };
 
-class CpuOveruseObserverImpl : public CpuOveruseObserver {
+class CpuOveruseObserverImpl : public ScalingInterface {
  public:
   CpuOveruseObserverImpl() :
     overuse_(0),
     normaluse_(0) {}
   virtual ~CpuOveruseObserverImpl() {}
 
-  void OveruseDetected() { ++overuse_; }
-  void NormalUsage() { ++normaluse_; }
+  void ScaleDown() { ++overuse_; }
+  void ScaleUp() { ++normaluse_; }
 
   int overuse_;
   int normaluse_;
@@ -56,7 +57,7 @@ class OveruseFrameDetectorUnderTest : public OveruseFrameDetector {
  public:
   OveruseFrameDetectorUnderTest(Clock* clock,
                                 const CpuOveruseOptions& options,
-                                CpuOveruseObserver* overuse_observer,
+                                ScalingInterface* overuse_observer,
                                 EncodedFrameObserver* encoder_timing,
                                 CpuOveruseMetricsObserver* metrics_observer)
       : OveruseFrameDetector(clock,
@@ -152,33 +153,33 @@ class OveruseFrameDetectorTest : public ::testing::Test,
 // UsagePercent() < low_encode_usage_threshold_percent => underuse.
 TEST_F(OveruseFrameDetectorTest, TriggerOveruse) {
   // usage > high => overuse
-  EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
+  EXPECT_CALL(*(observer_.get()), ScaleDown()).Times(1);
   TriggerOveruse(options_.high_threshold_consecutive_count);
 }
 
 TEST_F(OveruseFrameDetectorTest, OveruseAndRecover) {
   // usage > high => overuse
-  EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
+  EXPECT_CALL(*(observer_.get()), ScaleDown()).Times(1);
   TriggerOveruse(options_.high_threshold_consecutive_count);
   // usage < low => underuse
-  EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(testing::AtLeast(1));
+  EXPECT_CALL(*(observer_.get()), ScaleUp()).Times(testing::AtLeast(1));
   TriggerUnderuse();
 }
 
 TEST_F(OveruseFrameDetectorTest, OveruseAndRecoverWithNoObserver) {
   overuse_detector_.reset(new OveruseFrameDetectorUnderTest(
       clock_.get(), options_, nullptr, nullptr, this));
-  EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(0);
+  EXPECT_CALL(*(observer_.get()), ScaleDown()).Times(0);
   TriggerOveruse(options_.high_threshold_consecutive_count);
-  EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
+  EXPECT_CALL(*(observer_.get()), ScaleUp()).Times(0);
   TriggerUnderuse();
 }
 
 TEST_F(OveruseFrameDetectorTest, DoubleOveruseAndRecover) {
-  EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(2);
+  EXPECT_CALL(*(observer_.get()), ScaleDown()).Times(2);
   TriggerOveruse(options_.high_threshold_consecutive_count);
   TriggerOveruse(options_.high_threshold_consecutive_count);
-  EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(testing::AtLeast(1));
+  EXPECT_CALL(*(observer_.get()), ScaleUp()).Times(testing::AtLeast(1));
   TriggerUnderuse();
 }
 
@@ -197,22 +198,22 @@ TEST_F(OveruseFrameDetectorTest, TriggerUnderuseWithMinProcessCount) {
 }
 
 TEST_F(OveruseFrameDetectorTest, ConstantOveruseGivesNoNormalUsage) {
-  EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
-  EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(64);
+  EXPECT_CALL(*(observer_.get()), ScaleUp()).Times(0);
+  EXPECT_CALL(*(observer_.get()), ScaleDown()).Times(64);
   for (size_t i = 0; i < 64; ++i) {
     TriggerOveruse(options_.high_threshold_consecutive_count);
   }
 }
 
 TEST_F(OveruseFrameDetectorTest, ConsecutiveCountTriggersOveruse) {
-  EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
+  EXPECT_CALL(*(observer_.get()), ScaleDown()).Times(1);
   options_.high_threshold_consecutive_count = 2;
   ReinitializeOveruseDetector();
   TriggerOveruse(2);
 }
 
 TEST_F(OveruseFrameDetectorTest, IncorrectConsecutiveCountTriggersNoOveruse) {
-  EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(0);
+  EXPECT_CALL(*(observer_.get()), ScaleDown()).Times(0);
   options_.high_threshold_consecutive_count = 2;
   ReinitializeOveruseDetector();
   TriggerOveruse(1);
@@ -278,7 +279,7 @@ TEST_F(OveruseFrameDetectorTest, InitialProcessingUsage) {
 }
 
 TEST_F(OveruseFrameDetectorTest, MeasuresMultipleConcurrentSamples) {
-  EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(testing::AtLeast(1));
+  EXPECT_CALL(*(observer_.get()), ScaleDown()).Times(testing::AtLeast(1));
   static const int kIntervalMs = 33;
   static const size_t kNumFramesEncodingDelay = 3;
   VideoFrame frame;
@@ -299,7 +300,7 @@ TEST_F(OveruseFrameDetectorTest, MeasuresMultipleConcurrentSamples) {
 
 TEST_F(OveruseFrameDetectorTest, UpdatesExistingSamples) {
   // >85% encoding time should trigger overuse.
-  EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(testing::AtLeast(1));
+  EXPECT_CALL(*(observer_.get()), ScaleDown()).Times(testing::AtLeast(1));
   static const int kIntervalMs = 33;
   static const int kDelayMs = 30;
   VideoFrame frame;
@@ -332,11 +333,10 @@ TEST_F(OveruseFrameDetectorTest, RunOnTqNormalUsage) {
 
   // Expect NormalUsage(). When called, stop the |overuse_detector_| and then
   // set |event| to end the test.
-  EXPECT_CALL(*(observer_.get()), NormalUsage())
-      .WillOnce(Invoke([this, &event] {
-        overuse_detector_->StopCheckForOveruse();
-        event.Set();
-      }));
+  EXPECT_CALL(*(observer_.get()), ScaleUp()).WillOnce(Invoke([this, &event] {
+    overuse_detector_->StopCheckForOveruse();
+    event.Set();
+  }));
 
   queue.PostTask([this, &event] {
     const int kDelayMs1 = 5;