Let ViEEncoder express resolution requests as Sinkwants

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.
  */
 
@@ skipping 39 matching lines @@
 
   int overuse_;
   int normaluse_;
 };
 
 class OveruseFrameDetectorUnderTest : public OveruseFrameDetector {
  public:
   OveruseFrameDetectorUnderTest(Clock* clock,
                                 const CpuOveruseOptions& options,
                                 CpuOveruseObserver* overuse_observer,
-                                EncodedFrameObserver* encoder_timing,
                                 CpuOveruseMetricsObserver* metrics_observer)
       : OveruseFrameDetector(clock,
                              options,
                              overuse_observer,
-                             encoder_timing,
                              metrics_observer) {}
   ~OveruseFrameDetectorUnderTest() {}
 
   using OveruseFrameDetector::CheckForOveruse;
 };
 
 class OveruseFrameDetectorTest : public ::testing::Test,
                                  public CpuOveruseMetricsObserver {
  protected:
   void SetUp() override {
     clock_.reset(new SimulatedClock(1234));
     observer_.reset(new MockCpuOveruseObserver());
     options_.min_process_count = 0;
     ReinitializeOveruseDetector();
   }
 
   void ReinitializeOveruseDetector() {
     overuse_detector_.reset(new OveruseFrameDetectorUnderTest(
-        clock_.get(), options_, observer_.get(), nullptr, this));
+        clock_.get(), options_, observer_.get(), this));
   }
 
   void OnEncodedFrameTimeMeasured(int encode_time_ms,
                                   const CpuOveruseMetrics& metrics) override {
     metrics_ = metrics;
   }
 
   int InitialUsage() {
     return ((options_.low_encode_usage_threshold_percent +
              options_.high_encode_usage_threshold_percent) / 2.0f) + 0.5;
@@ skipping 64 matching lines @@
 TEST_F(OveruseFrameDetectorTest, OveruseAndRecover) {
   // usage > high => overuse
   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
   TriggerOveruse(options_.high_threshold_consecutive_count);
   // usage < low => underuse
   EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(testing::AtLeast(1));
   TriggerUnderuse();
 }
 
 TEST_F(OveruseFrameDetectorTest, OveruseAndRecoverWithNoObserver) {
-  overuse_detector_.reset(new OveruseFrameDetectorUnderTest(
-      clock_.get(), options_, nullptr, nullptr, this));
+  overuse_detector_.reset(
+      new OveruseFrameDetectorUnderTest(clock_.get(), options_, nullptr, this));
   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(0);
   TriggerOveruse(options_.high_threshold_consecutive_count);
   EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
   TriggerUnderuse();
 }
 
 TEST_F(OveruseFrameDetectorTest, DoubleOveruseAndRecover) {
   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(2);
   TriggerOveruse(options_.high_threshold_consecutive_count);
   TriggerOveruse(options_.high_threshold_consecutive_count);
   EXPECT_CALL(*(observer_.get()), NormalUsage()).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));
+      clock_.get(), options_, &overuse_observer, 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) {
@@ skipping 123 matching lines @@
 TEST_F(OveruseFrameDetectorTest, RunOnTqNormalUsage) {
   rtc::TaskQueue queue("OveruseFrameDetectorTestQueue");
 
   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 NormalUsage().
   EXPECT_CALL(*(observer_.get()), NormalUsage())
       .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);
   });
 
+  // Wait for NormalUsage().
+  EXPECT_TRUE(event.Wait(10000));
+
+  // Delete the detector on TQ.
+  queue.PostTask([this, &event] {
+    overuse_detector_.reset();
+    event.Set();
+  });
   EXPECT_TRUE(event.Wait(10000));
 }
 
 }  // namespace webrtc