src/third_party/webrtc/video_engine/overuse_frame_detector_unittest.cc

   1 /*
   2  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include "testing/gmock/include/gmock/gmock.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 #include "webrtc/system_wrappers/interface/clock.h"
  15 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
  16 #include "webrtc/video_engine/include/vie_base.h"
  17 #include "webrtc/video_engine/overuse_frame_detector.h"
  18
  19 namespace webrtc {
  20 namespace {
  21   const int kWidth = 640;
  22   const int kHeight = 480;
  23   const int kFrameInterval33ms = 33;
  24   const int kProcessIntervalMs = 5000;
  25 }  // namespace
  26
  27 class MockCpuOveruseObserver : public CpuOveruseObserver {
  28  public:
  29   MockCpuOveruseObserver() {}
  30   virtual ~MockCpuOveruseObserver() {}
  31
  32   MOCK_METHOD0(OveruseDetected, void());
  33   MOCK_METHOD0(NormalUsage, void());
  34 };
  35
  36 class CpuOveruseObserverImpl : public CpuOveruseObserver {
  37  public:
  38   CpuOveruseObserverImpl() :
  39     overuse_(0),
  40     normaluse_(0) {}
  41   virtual ~CpuOveruseObserverImpl() {}
  42
  43   void OveruseDetected() { ++overuse_; }
  44   void NormalUsage() { ++normaluse_; }
  45
  46   int overuse_;
  47   int normaluse_;
  48 };
  49
  50 class OveruseFrameDetectorTest : public ::testing::Test {
  51  protected:
  52   virtual void SetUp() {
  53     clock_.reset(new SimulatedClock(1234));
  54     observer_.reset(new MockCpuOveruseObserver());
  55     overuse_detector_.reset(new OveruseFrameDetector(clock_.get()));
  56
  57     options_.low_capture_jitter_threshold_ms = 10.0f;
  58     options_.high_capture_jitter_threshold_ms = 15.0f;
  59     options_.min_process_count = 0;
  60     overuse_detector_->SetOptions(options_);
  61     overuse_detector_->SetObserver(observer_.get());
  62   }
  63
  64   int InitialJitter() {
  65     return ((options_.low_capture_jitter_threshold_ms +
  66              options_.high_capture_jitter_threshold_ms) / 2.0f) + 0.5;
  67   }
  68
  69   int InitialUsage() {
  70     return ((options_.low_encode_usage_threshold_percent +
  71              options_.high_encode_usage_threshold_percent) / 2.0f) + 0.5;
  72   }
  73
  74   void InsertFramesWithInterval(
  75       size_t num_frames, int interval_ms, int width, int height) {
  76     while (num_frames-- > 0) {
  77       clock_->AdvanceTimeMilliseconds(interval_ms);
  78       overuse_detector_->FrameCaptured(width, height,
  79                                        clock_->TimeInMilliseconds());
  80     }
  81   }
  82
  83   void InsertAndSendFramesWithInterval(
  84       int num_frames, int interval_ms, int width, int height, int delay_ms) {
  85     while (num_frames-- > 0) {
  86       int64_t capture_time_ms = clock_->TimeInMilliseconds();
  87       overuse_detector_->FrameCaptured(width, height, capture_time_ms);
  88       clock_->AdvanceTimeMilliseconds(delay_ms);
  89       overuse_detector_->FrameEncoded(delay_ms);
  90       overuse_detector_->FrameSent(capture_time_ms);
  91       clock_->AdvanceTimeMilliseconds(interval_ms - delay_ms);
  92     }
  93   }
  94
  95   void TriggerOveruse(int num_times) {
  96     for (int i = 0; i < num_times; ++i) {
  97       InsertFramesWithInterval(200, kFrameInterval33ms, kWidth, kHeight);
  98       InsertFramesWithInterval(50, 110, kWidth, kHeight);
  99       overuse_detector_->Process();
 100     }
 101   }
 102
 103   void TriggerUnderuse() {
 104     InsertFramesWithInterval(900, kFrameInterval33ms, kWidth, kHeight);
 105     overuse_detector_->Process();
 106   }
 107
 108   void TriggerOveruseWithProcessingUsage(int num_times) {
 109     const int kDelayMs = 32;
 110     for (int i = 0; i < num_times; ++i) {
 111       InsertAndSendFramesWithInterval(
 112           1000, kFrameInterval33ms, kWidth, kHeight, kDelayMs);
 113       overuse_detector_->Process();
 114     }
 115   }
 116
 117   void TriggerUnderuseWithProcessingUsage() {
 118     const int kDelayMs1 = 5;
 119     const int kDelayMs2 = 6;
 120     InsertAndSendFramesWithInterval(
 121         1300, kFrameInterval33ms, kWidth, kHeight, kDelayMs1);
 122     InsertAndSendFramesWithInterval(
 123         1, kFrameInterval33ms, kWidth, kHeight, kDelayMs2);
 124     overuse_detector_->Process();
 125   }
 126
 127   int CaptureJitterMs() {
 128     CpuOveruseMetrics metrics;
 129     overuse_detector_->GetCpuOveruseMetrics(&metrics);
 130     return metrics.capture_jitter_ms;
 131   }
 132
 133   int AvgEncodeTimeMs() {
 134     CpuOveruseMetrics metrics;
 135     overuse_detector_->GetCpuOveruseMetrics(&metrics);
 136     return metrics.avg_encode_time_ms;
 137   }
 138
 139   int UsagePercent() {
 140     CpuOveruseMetrics metrics;
 141     overuse_detector_->GetCpuOveruseMetrics(&metrics);
 142     return metrics.encode_usage_percent;
 143   }
 144
 145   CpuOveruseOptions options_;
 146   scoped_ptr<SimulatedClock> clock_;
 147   scoped_ptr<MockCpuOveruseObserver> observer_;
 148   scoped_ptr<OveruseFrameDetector> overuse_detector_;
 149 };
 150
 151 // enable_capture_jitter_method = true;
 152 // CaptureJitterMs() > high_capture_jitter_threshold_ms => overuse.
 153 // CaptureJitterMs() < low_capture_jitter_threshold_ms => underuse.
 154 TEST_F(OveruseFrameDetectorTest, TriggerOveruse) {
 155   // capture_jitter > high => overuse
 156   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
 157   TriggerOveruse(options_.high_threshold_consecutive_count);
 158 }
 159
 160 TEST_F(OveruseFrameDetectorTest, OveruseAndRecover) {
 161   // capture_jitter > high => overuse
 162   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
 163   TriggerOveruse(options_.high_threshold_consecutive_count);
 164   // capture_jitter < low => underuse
 165   EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(testing::AtLeast(1));
 166   TriggerUnderuse();
 167 }
 168
 169 TEST_F(OveruseFrameDetectorTest, OveruseAndRecoverWithNoObserver) {
 170   overuse_detector_->SetObserver(NULL);
 171   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(0);
 172   TriggerOveruse(options_.high_threshold_consecutive_count);
 173   EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
 174   TriggerUnderuse();
 175 }
 176
 177 TEST_F(OveruseFrameDetectorTest, OveruseAndRecoverWithMethodDisabled) {
 178   options_.enable_capture_jitter_method = false;
 179   options_.enable_encode_usage_method = false;
 180   overuse_detector_->SetOptions(options_);
 181   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(0);
 182   TriggerOveruse(options_.high_threshold_consecutive_count);
 183   EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
 184   TriggerUnderuse();
 185 }
 186
 187 TEST_F(OveruseFrameDetectorTest, DoubleOveruseAndRecover) {
 188   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(2);
 189   TriggerOveruse(options_.high_threshold_consecutive_count);
 190   TriggerOveruse(options_.high_threshold_consecutive_count);
 191   EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(testing::AtLeast(1));
 192   TriggerUnderuse();
 193 }
 194
 195 TEST_F(OveruseFrameDetectorTest, TriggerUnderuseWithMinProcessCount) {
 196   CpuOveruseObserverImpl overuse_observer_;
 197   overuse_detector_->SetObserver(&overuse_observer_);
 198   options_.min_process_count = 1;
 199   overuse_detector_->SetOptions(options_);
 200   InsertFramesWithInterval(1200, kFrameInterval33ms, kWidth, kHeight);
 201   overuse_detector_->Process();
 202   EXPECT_EQ(0, overuse_observer_.normaluse_);
 203   clock_->AdvanceTimeMilliseconds(kProcessIntervalMs);
 204   overuse_detector_->Process();
 205   EXPECT_EQ(1, overuse_observer_.normaluse_);
 206 }
 207
 208 TEST_F(OveruseFrameDetectorTest, ConstantOveruseGivesNoNormalUsage) {
 209   EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
 210   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(64);
 211   for(size_t i = 0; i < 64; ++i) {
 212     TriggerOveruse(options_.high_threshold_consecutive_count);
 213   }
 214 }
 215
 216 TEST_F(OveruseFrameDetectorTest, ConsecutiveCountTriggersOveruse) {
 217   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
 218   options_.high_threshold_consecutive_count = 2;
 219   overuse_detector_->SetOptions(options_);
 220   TriggerOveruse(2);
 221 }
 222
 223 TEST_F(OveruseFrameDetectorTest, IncorrectConsecutiveCountTriggersNoOveruse) {
 224   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(0);
 225   options_.high_threshold_consecutive_count = 2;
 226   overuse_detector_->SetOptions(options_);
 227   TriggerOveruse(1);
 228 }
 229
 230 TEST_F(OveruseFrameDetectorTest, GetCpuOveruseMetrics) {
 231   CpuOveruseMetrics metrics;
 232   overuse_detector_->GetCpuOveruseMetrics(&metrics);
 233   EXPECT_GT(metrics.capture_jitter_ms, 0);
 234   EXPECT_GT(metrics.avg_encode_time_ms, 0);
 235   EXPECT_GT(metrics.encode_usage_percent, 0);
 236   EXPECT_GE(metrics.capture_queue_delay_ms_per_s, 0);
 237   EXPECT_GE(metrics.encode_rsd, 0);
 238 }
 239
 240 TEST_F(OveruseFrameDetectorTest, CaptureJitter) {
 241   EXPECT_EQ(InitialJitter(), CaptureJitterMs());
 242   InsertFramesWithInterval(1000, kFrameInterval33ms, kWidth, kHeight);
 243   EXPECT_NE(InitialJitter(), CaptureJitterMs());
 244 }
 245
 246 TEST_F(OveruseFrameDetectorTest, CaptureJitterResetAfterResolutionChange) {
 247   EXPECT_EQ(InitialJitter(), CaptureJitterMs());
 248   InsertFramesWithInterval(1000, kFrameInterval33ms, kWidth, kHeight);
 249   EXPECT_NE(InitialJitter(), CaptureJitterMs());
 250   // Verify reset.
 251   InsertFramesWithInterval(1, kFrameInterval33ms, kWidth, kHeight + 1);
 252   EXPECT_EQ(InitialJitter(), CaptureJitterMs());
 253 }
 254
 255 TEST_F(OveruseFrameDetectorTest, CaptureJitterResetAfterFrameTimeout) {
 256   EXPECT_EQ(InitialJitter(), CaptureJitterMs());
 257   InsertFramesWithInterval(1000, kFrameInterval33ms, kWidth, kHeight);
 258   EXPECT_NE(InitialJitter(), CaptureJitterMs());
 259   InsertFramesWithInterval(
 260       1, options_.frame_timeout_interval_ms, kWidth, kHeight);
 261   EXPECT_NE(InitialJitter(), CaptureJitterMs());
 262   // Verify reset.
 263   InsertFramesWithInterval(
 264       1, options_.frame_timeout_interval_ms + 1, kWidth, kHeight);
 265   EXPECT_EQ(InitialJitter(), CaptureJitterMs());
 266 }
 267
 268 TEST_F(OveruseFrameDetectorTest, CaptureJitterResetAfterChangingThreshold) {
 269   EXPECT_EQ(InitialJitter(), CaptureJitterMs());
 270   options_.high_capture_jitter_threshold_ms = 90.0f;
 271   overuse_detector_->SetOptions(options_);
 272   EXPECT_EQ(InitialJitter(), CaptureJitterMs());
 273   options_.low_capture_jitter_threshold_ms = 30.0f;
 274   overuse_detector_->SetOptions(options_);
 275   EXPECT_EQ(InitialJitter(), CaptureJitterMs());
 276 }
 277
 278 TEST_F(OveruseFrameDetectorTest, MinFrameSamplesBeforeUpdatingCaptureJitter) {
 279   options_.min_frame_samples = 40;
 280   overuse_detector_->SetOptions(options_);
 281   InsertFramesWithInterval(40, kFrameInterval33ms, kWidth, kHeight);
 282   EXPECT_EQ(InitialJitter(), CaptureJitterMs());
 283 }
 284
 285 TEST_F(OveruseFrameDetectorTest, NoCaptureQueueDelay) {
 286   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 0);
 287   overuse_detector_->FrameCaptured(
 288       kWidth, kHeight, clock_->TimeInMilliseconds());
 289   overuse_detector_->FrameProcessingStarted();
 290   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 0);
 291 }
 292
 293 TEST_F(OveruseFrameDetectorTest, CaptureQueueDelay) {
 294   overuse_detector_->FrameCaptured(
 295       kWidth, kHeight, clock_->TimeInMilliseconds());
 296   clock_->AdvanceTimeMilliseconds(100);
 297   overuse_detector_->FrameProcessingStarted();
 298   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 100);
 299 }
 300
 301 TEST_F(OveruseFrameDetectorTest, CaptureQueueDelayMultipleFrames) {
 302   overuse_detector_->FrameCaptured(
 303       kWidth, kHeight, clock_->TimeInMilliseconds());
 304   clock_->AdvanceTimeMilliseconds(10);
 305   overuse_detector_->FrameCaptured(
 306       kWidth, kHeight, clock_->TimeInMilliseconds());
 307   clock_->AdvanceTimeMilliseconds(20);
 308
 309   overuse_detector_->FrameProcessingStarted();
 310   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 30);
 311   overuse_detector_->FrameProcessingStarted();
 312   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 20);
 313 }
 314
 315 TEST_F(OveruseFrameDetectorTest, CaptureQueueDelayResetAtResolutionSwitch) {
 316   overuse_detector_->FrameCaptured(
 317       kWidth, kHeight, clock_->TimeInMilliseconds());
 318   clock_->AdvanceTimeMilliseconds(10);
 319   overuse_detector_->FrameCaptured(
 320       kWidth, kHeight + 1, clock_->TimeInMilliseconds());
 321   clock_->AdvanceTimeMilliseconds(20);
 322
 323   overuse_detector_->FrameProcessingStarted();
 324   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 20);
 325 }
 326
 327 TEST_F(OveruseFrameDetectorTest, CaptureQueueDelayNoMatchingCapturedFrame) {
 328   overuse_detector_->FrameCaptured(
 329       kWidth, kHeight, clock_->TimeInMilliseconds());
 330   clock_->AdvanceTimeMilliseconds(100);
 331   overuse_detector_->FrameProcessingStarted();
 332   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 100);
 333   // No new captured frame. The last delay should be reported.
 334   overuse_detector_->FrameProcessingStarted();
 335   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 100);
 336 }
 337
 338 TEST_F(OveruseFrameDetectorTest, FrameDelay_OneFrameDisabled) {
 339   options_.enable_extended_processing_usage = false;
 340   overuse_detector_->SetOptions(options_);
 341   const int kProcessingTimeMs = 100;
 342   overuse_detector_->FrameCaptured(kWidth, kHeight, 33);
 343   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
 344   overuse_detector_->FrameSent(33);
 345   EXPECT_EQ(-1, overuse_detector_->LastProcessingTimeMs());
 346 }
 347
 348 TEST_F(OveruseFrameDetectorTest, FrameDelay_OneFrame) {
 349   options_.enable_extended_processing_usage = true;
 350   overuse_detector_->SetOptions(options_);
 351   const int kProcessingTimeMs = 100;
 352   overuse_detector_->FrameCaptured(kWidth, kHeight, 33);
 353   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
 354   EXPECT_EQ(-1, overuse_detector_->LastProcessingTimeMs());
 355   overuse_detector_->FrameSent(33);
 356   EXPECT_EQ(kProcessingTimeMs, overuse_detector_->LastProcessingTimeMs());
 357   EXPECT_EQ(0, overuse_detector_->FramesInQueue());
 358 }
 359
 360 TEST_F(OveruseFrameDetectorTest, FrameDelay_TwoFrames) {
 361   options_.enable_extended_processing_usage = true;
 362   overuse_detector_->SetOptions(options_);
 363   const int kProcessingTimeMs1 = 100;
 364   const int kProcessingTimeMs2 = 50;
 365   const int kTimeBetweenFramesMs = 200;
 366   overuse_detector_->FrameCaptured(kWidth, kHeight, 33);
 367   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs1);
 368   overuse_detector_->FrameSent(33);
 369   EXPECT_EQ(kProcessingTimeMs1, overuse_detector_->LastProcessingTimeMs());
 370   clock_->AdvanceTimeMilliseconds(kTimeBetweenFramesMs);
 371   overuse_detector_->FrameCaptured(kWidth, kHeight, 66);
 372   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs2);
 373   overuse_detector_->FrameSent(66);
 374   EXPECT_EQ(kProcessingTimeMs2, overuse_detector_->LastProcessingTimeMs());
 375 }
 376
 377 TEST_F(OveruseFrameDetectorTest, FrameDelay_MaxQueueSize) {
 378   options_.enable_extended_processing_usage = true;
 379   overuse_detector_->SetOptions(options_);
 380   const int kMaxQueueSize = 91;
 381   for (int i = 0; i < kMaxQueueSize * 2; ++i) {
 382     overuse_detector_->FrameCaptured(kWidth, kHeight, i);
 383   }
 384   EXPECT_EQ(kMaxQueueSize, overuse_detector_->FramesInQueue());
 385 }
 386
 387 TEST_F(OveruseFrameDetectorTest, FrameDelay_NonProcessedFramesRemoved) {
 388   options_.enable_extended_processing_usage = true;
 389   overuse_detector_->SetOptions(options_);
 390   const int kProcessingTimeMs = 100;
 391   overuse_detector_->FrameCaptured(kWidth, kHeight, 33);
 392   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
 393   overuse_detector_->FrameCaptured(kWidth, kHeight, 35);
 394   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
 395   overuse_detector_->FrameCaptured(kWidth, kHeight, 66);
 396   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
 397   overuse_detector_->FrameCaptured(kWidth, kHeight, 99);
 398   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
 399   EXPECT_EQ(-1, overuse_detector_->LastProcessingTimeMs());
 400   EXPECT_EQ(4, overuse_detector_->FramesInQueue());
 401   overuse_detector_->FrameSent(66);
 402   // Frame 33, 35 removed, 66 processed, 99 not processed.
 403   EXPECT_EQ(2 * kProcessingTimeMs, overuse_detector_->LastProcessingTimeMs());
 404   EXPECT_EQ(1, overuse_detector_->FramesInQueue());
 405   overuse_detector_->FrameSent(99);
 406   EXPECT_EQ(kProcessingTimeMs, overuse_detector_->LastProcessingTimeMs());
 407   EXPECT_EQ(0, overuse_detector_->FramesInQueue());
 408 }
 409
 410 TEST_F(OveruseFrameDetectorTest, FrameDelay_ResetClearsFrames) {
 411   options_.enable_extended_processing_usage = true;
 412   overuse_detector_->SetOptions(options_);
 413   const int kProcessingTimeMs = 100;
 414   overuse_detector_->FrameCaptured(kWidth, kHeight, 33);
 415   EXPECT_EQ(1, overuse_detector_->FramesInQueue());
 416   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
 417   // Verify reset (resolution changed).
 418   overuse_detector_->FrameCaptured(kWidth, kHeight + 1, 66);
 419   EXPECT_EQ(1, overuse_detector_->FramesInQueue());
 420   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
 421   overuse_detector_->FrameSent(66);
 422   EXPECT_EQ(kProcessingTimeMs, overuse_detector_->LastProcessingTimeMs());
 423   EXPECT_EQ(0, overuse_detector_->FramesInQueue());
 424 }
 425
 426 TEST_F(OveruseFrameDetectorTest, FrameDelay_NonMatchingSendFrameIgnored) {
 427   options_.enable_extended_processing_usage = true;
 428   overuse_detector_->SetOptions(options_);
 429   const int kProcessingTimeMs = 100;
 430   overuse_detector_->FrameCaptured(kWidth, kHeight, 33);
 431   clock_->AdvanceTimeMilliseconds(kProcessingTimeMs);
 432   overuse_detector_->FrameSent(34);
 433   EXPECT_EQ(-1, overuse_detector_->LastProcessingTimeMs());
 434   overuse_detector_->FrameSent(33);
 435   EXPECT_EQ(kProcessingTimeMs, overuse_detector_->LastProcessingTimeMs());
 436 }
 437
 438 TEST_F(OveruseFrameDetectorTest, EncodedFrame) {
 439   const int kInitialAvgEncodeTimeInMs = 5;
 440   EXPECT_EQ(kInitialAvgEncodeTimeInMs, AvgEncodeTimeMs());
 441   for (int i = 0; i < 30; i++) {
 442     clock_->AdvanceTimeMilliseconds(33);
 443     overuse_detector_->FrameEncoded(2);
 444   }
 445   EXPECT_EQ(2, AvgEncodeTimeMs());
 446 }
 447
 448 TEST_F(OveruseFrameDetectorTest, InitialProcessingUsage) {
 449   EXPECT_EQ(InitialUsage(), UsagePercent());
 450 }
 451
 452 TEST_F(OveruseFrameDetectorTest, ProcessingUsage) {
 453   const int kProcessingTimeMs = 5;
 454   InsertAndSendFramesWithInterval(
 455       1000, kFrameInterval33ms, kWidth, kHeight, kProcessingTimeMs);
 456   EXPECT_EQ(kProcessingTimeMs * 100 / kFrameInterval33ms, UsagePercent());
 457 }
 458
 459 TEST_F(OveruseFrameDetectorTest, ProcessingUsageResetAfterChangingThreshold) {
 460   EXPECT_EQ(InitialUsage(), UsagePercent());
 461   options_.high_encode_usage_threshold_percent = 100;
 462   overuse_detector_->SetOptions(options_);
 463   EXPECT_EQ(InitialUsage(), UsagePercent());
 464   options_.low_encode_usage_threshold_percent = 20;
 465   overuse_detector_->SetOptions(options_);
 466   EXPECT_EQ(InitialUsage(), UsagePercent());
 467 }
 468
 469 // enable_encode_usage_method = true;
 470 // UsagePercent() > high_encode_usage_threshold_percent => overuse.
 471 // UsagePercent() < low_encode_usage_threshold_percent => underuse.
 472 TEST_F(OveruseFrameDetectorTest, TriggerOveruseWithProcessingUsage) {
 473   options_.enable_capture_jitter_method = false;
 474   options_.enable_encode_usage_method = true;
 475   options_.enable_extended_processing_usage = false;
 476   overuse_detector_->SetOptions(options_);
 477   // usage > high => overuse
 478   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
 479   TriggerOveruseWithProcessingUsage(options_.high_threshold_consecutive_count);
 480 }
 481
 482 TEST_F(OveruseFrameDetectorTest, OveruseAndRecoverWithProcessingUsage) {
 483   options_.enable_capture_jitter_method = false;
 484   options_.enable_encode_usage_method = true;
 485   options_.enable_extended_processing_usage = false;
 486   overuse_detector_->SetOptions(options_);
 487   // usage > high => overuse
 488   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
 489   TriggerOveruseWithProcessingUsage(options_.high_threshold_consecutive_count);
 490   // usage < low => underuse
 491   EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(testing::AtLeast(1));
 492   TriggerUnderuseWithProcessingUsage();
 493 }
 494
 495 TEST_F(OveruseFrameDetectorTest,
 496        OveruseAndRecoverWithProcessingUsageMethodDisabled) {
 497   options_.enable_capture_jitter_method = false;
 498   options_.enable_encode_usage_method = false;
 499   options_.enable_extended_processing_usage = false;
 500   overuse_detector_->SetOptions(options_);
 501   // usage > high => overuse
 502   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(0);
 503   TriggerOveruseWithProcessingUsage(options_.high_threshold_consecutive_count);
 504   // usage < low => underuse
 505   EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
 506   TriggerUnderuseWithProcessingUsage();
 507 }
 508
 509 // enable_extended_processing_usage = true;
 510 // enable_encode_usage_method = true;
 511 // UsagePercent() > high_encode_usage_threshold_percent => overuse.
 512 // UsagePercent() < low_encode_usage_threshold_percent => underuse.
 513 TEST_F(OveruseFrameDetectorTest, TriggerOveruseWithExtendedProcessingUsage) {
 514   options_.enable_capture_jitter_method = false;
 515   options_.enable_encode_usage_method = true;
 516   options_.enable_extended_processing_usage = true;
 517   overuse_detector_->SetOptions(options_);
 518   // usage > high => overuse
 519   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
 520   TriggerOveruseWithProcessingUsage(options_.high_threshold_consecutive_count);
 521 }
 522
 523 TEST_F(OveruseFrameDetectorTest, OveruseAndRecoverWithExtendedProcessingUsage) {
 524   options_.enable_capture_jitter_method = false;
 525   options_.enable_encode_usage_method = true;
 526   options_.enable_extended_processing_usage = true;
 527   overuse_detector_->SetOptions(options_);
 528   // usage > high => overuse
 529   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
 530   TriggerOveruseWithProcessingUsage(options_.high_threshold_consecutive_count);
 531   // usage < low => underuse
 532   EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(testing::AtLeast(1));
 533   TriggerUnderuseWithProcessingUsage();
 534 }
 535
 536 TEST_F(OveruseFrameDetectorTest,
 537        OveruseAndRecoverWithExtendedProcessingUsageMethodDisabled) {
 538   options_.enable_capture_jitter_method = false;
 539   options_.enable_encode_usage_method = false;
 540   options_.enable_extended_processing_usage = true;
 541   overuse_detector_->SetOptions(options_);
 542   // usage > high => overuse
 543   EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(0);
 544   TriggerOveruseWithProcessingUsage(options_.high_threshold_consecutive_count);
 545   // usage < low => underuse
 546   EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
 547   TriggerUnderuseWithProcessingUsage();
 548 }
 549
 550 }  // namespace webrtc