Remove always-on options in OveruseFrameDetector.

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 60 matching lines @@
     return ((options_.low_encode_usage_threshold_percent +
              options_.high_encode_usage_threshold_percent) / 2.0f) + 0.5;
   }
 
   void InsertAndSendFramesWithInterval(
       int num_frames, int interval_ms, int width, int height, int delay_ms) {
     while (num_frames-- > 0) {
       int64_t capture_time_ms = clock_->TimeInMilliseconds();
       overuse_detector_->FrameCaptured(width, height, capture_time_ms);
       clock_->AdvanceTimeMilliseconds(delay_ms);
-      overuse_detector_->FrameEncoded(delay_ms);
       overuse_detector_->FrameSent(capture_time_ms);
       clock_->AdvanceTimeMilliseconds(interval_ms - delay_ms);
     }
   }
 
   void TriggerOveruse(int num_times) {
     const int kDelayMs = 32;
     for (int i = 0; i < num_times; ++i) {
       InsertAndSendFramesWithInterval(
           1000, kFrameInterval33ms, kWidth, kHeight, kDelayMs);
@@ skipping 14 matching lines @@
   int UsagePercent() { return metrics_.encode_usage_percent; }
 
   CpuOveruseOptions options_;
   rtc::scoped_ptr<SimulatedClock> clock_;
   rtc::scoped_ptr<MockCpuOveruseObserver> observer_;
   rtc::scoped_ptr<OveruseFrameDetector> overuse_detector_;
   CpuOveruseMetrics metrics_;
 };
 
 
-// enable_encode_usage_method = true;
-// enable_extended_processing_usage = false;
 // UsagePercent() > high_encode_usage_threshold_percent => overuse.
 // UsagePercent() < low_encode_usage_threshold_percent => underuse.
 TEST_F(OveruseFrameDetectorTest, TriggerOveruse) {
-  options_.enable_extended_processing_usage = false;
-  ReinitializeOveruseDetector();
   // usage > high => overuse
   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
   TriggerOveruse(options_.high_threshold_consecutive_count);
 }
 
 TEST_F(OveruseFrameDetectorTest, OveruseAndRecover) {
-  options_.enable_extended_processing_usage = false;
-  ReinitializeOveruseDetector();
   // 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) {
-  options_.enable_extended_processing_usage = false;
   overuse_detector_.reset(
       new OveruseFrameDetector(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, OveruseAndRecoverWithMethodDisabled) {
-  options_.enable_encode_usage_method = false;
-  options_.enable_extended_processing_usage = false;
-  ReinitializeOveruseDetector();
-  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) {
-  options_.enable_extended_processing_usage = false;
-  ReinitializeOveruseDetector();
   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_.enable_extended_processing_usage = false;
   options_.min_process_count = 1;
   CpuOveruseObserverImpl overuse_observer;
   overuse_detector_.reset(new OveruseFrameDetector(clock_.get(), options_,
                                                    &overuse_observer, this));
   InsertAndSendFramesWithInterval(
       1200, kFrameInterval33ms, kWidth, kHeight, kProcessTime5ms);
   overuse_detector_->Process();
   EXPECT_EQ(0, overuse_observer.normaluse_);
   clock_->AdvanceTimeMilliseconds(kProcessIntervalMs);
   overuse_detector_->Process();
   EXPECT_EQ(1, overuse_observer.normaluse_);
 }
 
 TEST_F(OveruseFrameDetectorTest, ConstantOveruseGivesNoNormalUsage) {
-  options_.enable_extended_processing_usage = false;
-  ReinitializeOveruseDetector();
   EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
   EXPECT_CALL(*(observer_.get()), OveruseDetected()).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);
-  options_.enable_extended_processing_usage = false;
   options_.high_threshold_consecutive_count = 2;
   ReinitializeOveruseDetector();
   TriggerOveruse(2);
 }
 
 TEST_F(OveruseFrameDetectorTest, IncorrectConsecutiveCountTriggersNoOveruse) {
   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(0);
-  options_.enable_extended_processing_usage = false;
   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 32 matching lines @@
   EXPECT_EQ(InitialUsage(), UsagePercent());
   InsertAndSendFramesWithInterval(
       1, kFrameInterval33ms, kWidth, kHeight, kProcessTime5ms);
   EXPECT_NE(InitialUsage(), UsagePercent());
 }
 
 TEST_F(OveruseFrameDetectorTest, InitialProcessingUsage) {
   EXPECT_EQ(InitialUsage(), UsagePercent());
 }
 
-TEST_F(OveruseFrameDetectorTest, FrameDelay_OneFrameDisabled) {
-  options_.enable_extended_processing_usage = false;
-  ReinitializeOveruseDetector();
+TEST_F(OveruseFrameDetectorTest, FrameDelay_OneFrame) {
   const int kProcessingTimeMs = 100;
   overuse_detector_->FrameCaptured(kWidth, kHeight, 33);
   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
-  overuse_detector_->FrameSent(33);
-  EXPECT_EQ(-1, overuse_detector_->LastProcessingTimeMs());
-}
-
-TEST_F(OveruseFrameDetectorTest, FrameDelay_OneFrame) {
-  options_.enable_extended_processing_usage = true;
-  ReinitializeOveruseDetector();
-  const int kProcessingTimeMs = 100;
-  overuse_detector_->FrameCaptured(kWidth, kHeight, 33);
-  clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
   EXPECT_EQ(-1, overuse_detector_->LastProcessingTimeMs());
   overuse_detector_->FrameSent(33);
   EXPECT_EQ(kProcessingTimeMs, overuse_detector_->LastProcessingTimeMs());
   EXPECT_EQ(0, overuse_detector_->FramesInQueue());
 }
 
 TEST_F(OveruseFrameDetectorTest, FrameDelay_TwoFrames) {
-  options_.enable_extended_processing_usage = true;
-  ReinitializeOveruseDetector();
   const int kProcessingTimeMs1 = 100;
   const int kProcessingTimeMs2 = 50;
   const int kTimeBetweenFramesMs = 200;
   overuse_detector_->FrameCaptured(kWidth, kHeight, 33);
   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs1);
   overuse_detector_->FrameSent(33);
   EXPECT_EQ(kProcessingTimeMs1, overuse_detector_->LastProcessingTimeMs());
   clock_->AdvanceTimeMilliseconds(kTimeBetweenFramesMs);
   overuse_detector_->FrameCaptured(kWidth, kHeight, 66);
   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs2);
   overuse_detector_->FrameSent(66);
   EXPECT_EQ(kProcessingTimeMs2, overuse_detector_->LastProcessingTimeMs());
 }
 
 TEST_F(OveruseFrameDetectorTest, FrameDelay_MaxQueueSize) {
-  options_.enable_extended_processing_usage = true;
-  ReinitializeOveruseDetector();
   const int kMaxQueueSize = 91;
   for (int i = 0; i < kMaxQueueSize * 2; ++i) {
     overuse_detector_->FrameCaptured(kWidth, kHeight, i);
   }
   EXPECT_EQ(kMaxQueueSize, overuse_detector_->FramesInQueue());
 }
 
 TEST_F(OveruseFrameDetectorTest, FrameDelay_NonProcessedFramesRemoved) {
-  options_.enable_extended_processing_usage = true;
-  ReinitializeOveruseDetector();
   const int kProcessingTimeMs = 100;
   overuse_detector_->FrameCaptured(kWidth, kHeight, 33);
   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
   overuse_detector_->FrameCaptured(kWidth, kHeight, 35);
   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
   overuse_detector_->FrameCaptured(kWidth, kHeight, 66);
   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
   overuse_detector_->FrameCaptured(kWidth, kHeight, 99);
   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
   EXPECT_EQ(-1, overuse_detector_->LastProcessingTimeMs());
   EXPECT_EQ(4, overuse_detector_->FramesInQueue());
   overuse_detector_->FrameSent(66);
   // Frame 33, 35 removed, 66 processed, 99 not processed.
   EXPECT_EQ(2 * kProcessingTimeMs, overuse_detector_->LastProcessingTimeMs());
   EXPECT_EQ(1, overuse_detector_->FramesInQueue());
   overuse_detector_->FrameSent(99);
   EXPECT_EQ(kProcessingTimeMs, overuse_detector_->LastProcessingTimeMs());
   EXPECT_EQ(0, overuse_detector_->FramesInQueue());
 }
 
 TEST_F(OveruseFrameDetectorTest, FrameDelay_ResetClearsFrames) {
-  options_.enable_extended_processing_usage = true;
-  ReinitializeOveruseDetector();
   const int kProcessingTimeMs = 100;
   overuse_detector_->FrameCaptured(kWidth, kHeight, 33);
   EXPECT_EQ(1, overuse_detector_->FramesInQueue());
   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
   // Verify reset (resolution changed).
   overuse_detector_->FrameCaptured(kWidth, kHeight + 1, 66);
   EXPECT_EQ(1, overuse_detector_->FramesInQueue());
   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
   overuse_detector_->FrameSent(66);
   EXPECT_EQ(kProcessingTimeMs, overuse_detector_->LastProcessingTimeMs());
   EXPECT_EQ(0, overuse_detector_->FramesInQueue());
 }
 
 TEST_F(OveruseFrameDetectorTest, FrameDelay_NonMatchingSendFrameIgnored) {
-  options_.enable_extended_processing_usage = true;
-  ReinitializeOveruseDetector();
   const int kProcessingTimeMs = 100;
   overuse_detector_->FrameCaptured(kWidth, kHeight, 33);
   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
   overuse_detector_->FrameSent(34);
   EXPECT_EQ(-1, overuse_detector_->LastProcessingTimeMs());
   overuse_detector_->FrameSent(33);
   EXPECT_EQ(kProcessingTimeMs, overuse_detector_->LastProcessingTimeMs());
 }
 
-// enable_encode_usage_method = true;
-// enable_extended_processing_usage = true;
 // UsagePercent() > high_encode_usage_threshold_percent => overuse.

[åsapersson, 2016/01/07 15:02:46]

These two methods could be removed now (tested above).

[pbos-webrtc, 2016/01/07 15:36:35]

Done.

 // UsagePercent() < low_encode_usage_threshold_percent => underuse.
 TEST_F(OveruseFrameDetectorTest, TriggerOveruseWithExtendedProcessingUsage) {
-  options_.enable_extended_processing_usage = true;
-  ReinitializeOveruseDetector();
   // usage > high => overuse
   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
   TriggerOveruse(options_.high_threshold_consecutive_count);
 }
 
 TEST_F(OveruseFrameDetectorTest, OveruseAndRecoverWithExtendedProcessingUsage) {
-  options_.enable_extended_processing_usage = true;
-  ReinitializeOveruseDetector();
   // 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,
-       OveruseAndRecoverWithExtendedProcessingUsageMethodDisabled) {
-  options_.enable_encode_usage_method = false;
-  options_.enable_extended_processing_usage = true;
-  ReinitializeOveruseDetector();
-  // usage > high => overuse
-  EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(0);
-  TriggerOveruse(options_.high_threshold_consecutive_count);
-  // usage < low => underuse
-  EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
-  TriggerUnderuse();
-}
-
 }  // namespace webrtc