Move usage of QualityScaler to ViEEncoder.

webrtc/video/overuse_frame_detector_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.
  */
 
 #include <memory>
 
 #include "webrtc/base/event.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/test/gmock.h"
 #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 {
 
 using ::testing::Invoke;
 
 namespace {
   const int kWidth = 640;
   const int kHeight = 480;
   const int kFrameInterval33ms = 33;
   const int kProcessIntervalMs = 5000;
   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_;
 };
 
 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,
                              options,
                              overuse_observer,
                              encoder_timing,
                              metrics_observer) {}
   ~OveruseFrameDetectorUnderTest() {}
 
   using OveruseFrameDetector::CheckForOveruse;
@@ skipping 75 matching lines @@
   std::unique_ptr<MockCpuOveruseObserver> observer_;
   std::unique_ptr<OveruseFrameDetectorUnderTest> overuse_detector_;
   CpuOveruseMetrics metrics_;
 };
 
 
 // UsagePercent() > high_encode_usage_threshold_percent => overuse.
 // 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();
 }
 
 TEST_F(OveruseFrameDetectorTest, TriggerUnderuseWithMinProcessCount) {
   options_.min_process_count = 1;
   CpuOveruseObserverImpl overuse_observer;
   overuse_detector_.reset(new OveruseFrameDetectorUnderTest(
       clock_.get(), options_, &overuse_observer, nullptr, this));
   InsertAndSendFramesWithInterval(
       1200, kFrameInterval33ms, kWidth, kHeight, kProcessTime5ms);
   overuse_detector_->CheckForOveruse();
   EXPECT_EQ(0, overuse_observer.normaluse_);
   clock_->AdvanceTimeMilliseconds(kProcessIntervalMs);
   overuse_detector_->CheckForOveruse();
   EXPECT_EQ(1, overuse_observer.normaluse_);
 }
 
 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);
 }
 
 TEST_F(OveruseFrameDetectorTest, ProcessingUsage) {
   InsertAndSendFramesWithInterval(
       1000, kFrameInterval33ms, kWidth, kHeight, kProcessTime5ms);
   EXPECT_EQ(kProcessTime5ms * 100 / kFrameInterval33ms, UsagePercent());
 }
@@ skipping 45 matching lines @@
       1, kFrameInterval33ms, kWidth, kHeight, kProcessTime5ms);
   EXPECT_NE(InitialUsage(), UsagePercent());
 }
 
 TEST_F(OveruseFrameDetectorTest, InitialProcessingUsage) {
   ForceUpdate(kWidth, kHeight);
   EXPECT_EQ(InitialUsage(), UsagePercent());
 }
 
 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;
   frame.CreateEmptyFrame(kWidth, kHeight, kWidth, kWidth / 2, kWidth / 2);
   for (size_t i = 0; i < 1000; ++i) {
     // Unique timestamps.
     frame.set_timestamp(static_cast<uint32_t>(i));
     overuse_detector_->FrameCaptured(frame, clock_->TimeInMilliseconds());
     clock_->AdvanceTimeMilliseconds(kIntervalMs);
     if (i > kNumFramesEncodingDelay) {
       overuse_detector_->FrameSent(
           static_cast<uint32_t>(i - kNumFramesEncodingDelay),
           clock_->TimeInMilliseconds());
     }
     overuse_detector_->CheckForOveruse();
   }
 }
 
 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;
   frame.CreateEmptyFrame(kWidth, kHeight, kWidth, kWidth / 2, kWidth / 2);
   uint32_t timestamp = 0;
   for (size_t i = 0; i < 1000; ++i) {
     frame.set_timestamp(timestamp);
     overuse_detector_->FrameCaptured(frame, clock_->TimeInMilliseconds());
     // Encode and send first parts almost instantly.
     clock_->AdvanceTimeMilliseconds(1);
@@ skipping 12 matching lines @@
 
   rtc::Event event(false, false);
   queue.PostTask([this, &event] {
     overuse_detector_->StartCheckForOveruse();
     event.Set();
   });
   event.Wait(rtc::Event::kForever);
 
   // 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;
     const int kDelayMs2 = 6;
     InsertAndSendFramesWithInterval(1300, kFrameInterval33ms, kWidth, kHeight,
                                     kDelayMs1);
     InsertAndSendFramesWithInterval(1, kFrameInterval33ms, kWidth, kHeight,
                                     kDelayMs2);
   });
 
   EXPECT_TRUE(event.Wait(10000));
 }
 
 }  // namespace webrtc