Resolve dependency between rtc_event_log_api and remote_bitrate_estimator

webrtc/modules/remote_bitrate_estimator/overuse_detector_unittest.cc

 /*
  *  Copyright (c) 2012 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 41 matching lines @@
     for (int i = 0; i < 100000; ++i) {
       for (int j = 0; j < packets_per_frame; ++j) {
         UpdateDetector(rtp_timestamp_, receive_time_ms_, packet_size);
       }
       rtp_timestamp_ += mean_ms * 90;
       now_ms_ += mean_ms;
       receive_time_ms_ = std::max<int64_t>(
           receive_time_ms_,
           now_ms_ + static_cast<int64_t>(
                         random_.Gaussian(0, standard_deviation_ms) + 0.5));
-      if (kBwOverusing == overuse_detector_->State()) {
+      if (BandwidthUsage::kBwOverusing == overuse_detector_->State()) {
         if (last_overuse + 1 != i) {
           unique_overuse++;
         }
         last_overuse = i;
       }
     }
     return unique_overuse;
   }
 
   int RunUntilOveruse(int packets_per_frame, size_t packet_size, int mean_ms,
                       int standard_deviation_ms, int drift_per_frame_ms) {
     // Simulate a higher send pace, that is too high.
     for (int i = 0; i < 1000; ++i) {
       for (int j = 0; j < packets_per_frame; ++j) {
         UpdateDetector(rtp_timestamp_, receive_time_ms_, packet_size);
       }
       rtp_timestamp_ += mean_ms * 90;
       now_ms_ += mean_ms + drift_per_frame_ms;
       receive_time_ms_ = std::max<int64_t>(
           receive_time_ms_,
           now_ms_ + static_cast<int64_t>(
                         random_.Gaussian(0, standard_deviation_ms) + 0.5));
-      if (kBwOverusing == overuse_detector_->State()) {
+      if (BandwidthUsage::kBwOverusing == overuse_detector_->State()) {
         return i + 1;
       }
     }
     return -1;
   }
 
   void UpdateDetector(uint32_t rtp_timestamp, int64_t receive_time_ms,
                       size_t packet_size) {
     uint32_t timestamp_delta;
     int64_t time_delta;
@@ skipping 36 matching lines @@
 TEST_F(OveruseDetectorTest, SimpleNonOveruse30fps) {
   size_t packet_size = 1200;
   uint32_t frame_duration_ms = 33;
   uint32_t rtp_timestamp = 10 * 90;
 
   // No variance.
   for (int i = 0; i < 1000; ++i) {
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     now_ms_ += frame_duration_ms;
     rtp_timestamp += frame_duration_ms * 90;
-    EXPECT_EQ(kBwNormal, overuse_detector_->State());
+    EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
   }
 }
 
 // Roughly 1 Mbit/s
 TEST_F(OveruseDetectorTest, SimpleNonOveruseWithReceiveVariance) {
   uint32_t frame_duration_ms = 10;
   uint32_t rtp_timestamp = 10 * 90;
   size_t packet_size = 1200;
 
   for (int i = 0; i < 1000; ++i) {
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     rtp_timestamp += frame_duration_ms * 90;
     if (i % 2) {
       now_ms_ += frame_duration_ms - 5;
     } else {
       now_ms_ += frame_duration_ms + 5;
     }
-    EXPECT_EQ(kBwNormal, overuse_detector_->State());
+    EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
   }
 }
 
 TEST_F(OveruseDetectorTest, SimpleNonOveruseWithRtpTimestampVariance) {
   // Roughly 1 Mbit/s.
   uint32_t frame_duration_ms = 10;
   uint32_t rtp_timestamp = 10 * 90;
   size_t packet_size = 1200;
 
   for (int i = 0; i < 1000; ++i) {
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     now_ms_ += frame_duration_ms;
     if (i % 2) {
       rtp_timestamp += (frame_duration_ms - 5) * 90;
     } else {
       rtp_timestamp += (frame_duration_ms + 5) * 90;
     }
-    EXPECT_EQ(kBwNormal, overuse_detector_->State());
+    EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
   }
 }
 
 TEST_F(OveruseDetectorTest, SimpleOveruse2000Kbit30fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 6;
   int frame_duration_ms = 33;
   int drift_per_frame_ms = 1;
   int sigma_ms = 0;  // No variance.
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
@@ skipping 30 matching lines @@
   // Run 1000 samples to reach steady state.
   for (int i = 0; i < 1000; ++i) {
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     rtp_timestamp += frame_duration_ms * 90;
     if (i % 2) {
       offset = random_.Rand(0, 49);
       now_ms_ += frame_duration_ms - offset;
     } else {
       now_ms_ += frame_duration_ms + offset;
     }
-    EXPECT_EQ(kBwNormal, overuse_detector_->State());
+    EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
   }
   // Simulate a higher send pace, that is too high.
   // Above noise generate a standard deviation of approximately 28 ms.
   // Total build up of 150 ms.
   for (int j = 0; j < 15; ++j) {
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     now_ms_ += frame_duration_ms + drift_per_frame_ms;
     rtp_timestamp += frame_duration_ms * 90;
-    EXPECT_EQ(kBwNormal, overuse_detector_->State());
+    EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
   }
   UpdateDetector(rtp_timestamp, now_ms_, packet_size);
-  EXPECT_EQ(kBwOverusing, overuse_detector_->State());
+  EXPECT_EQ(BandwidthUsage::kBwOverusing, overuse_detector_->State());
 }
 
 TEST_F(OveruseDetectorTest, DISABLED_OveruseWithLowVariance100Kbit10fps) {
   uint32_t frame_duration_ms = 100;
   uint32_t drift_per_frame_ms = 1;
   uint32_t rtp_timestamp = frame_duration_ms * 90;
   size_t packet_size = 1200;
   int offset = 10;
 
   // Run 1000 samples to reach steady state.
   for (int i = 0; i < 1000; ++i) {
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     rtp_timestamp += frame_duration_ms * 90;
     if (i % 2) {
       offset = random_.Rand(0, 1);
       now_ms_ += frame_duration_ms - offset;
     } else {
       now_ms_ += frame_duration_ms + offset;
     }
-    EXPECT_EQ(kBwNormal, overuse_detector_->State());
+    EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
   }
   // Simulate a higher send pace, that is too high.
   // Total build up of 6 ms.
   for (int j = 0; j < 6; ++j) {
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     now_ms_ += frame_duration_ms + drift_per_frame_ms;
     rtp_timestamp += frame_duration_ms * 90;
-    EXPECT_EQ(kBwNormal, overuse_detector_->State());
+    EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
   }
   UpdateDetector(rtp_timestamp, now_ms_, packet_size);
-  EXPECT_EQ(kBwOverusing, overuse_detector_->State());
+  EXPECT_EQ(BandwidthUsage::kBwOverusing, overuse_detector_->State());
 }
 
 TEST_F(OveruseDetectorTest, OveruseWithLowVariance2000Kbit30fps) {
   uint32_t frame_duration_ms = 33;
   uint32_t drift_per_frame_ms = 1;
   uint32_t rtp_timestamp = frame_duration_ms * 90;
   size_t packet_size = 1200;
   int offset = 0;
 
   // Run 1000 samples to reach steady state.
   for (int i = 0; i < 1000; ++i) {
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     rtp_timestamp += frame_duration_ms * 90;
     if (i % 2) {
       offset = random_.Rand(0, 1);
       now_ms_ += frame_duration_ms - offset;
     } else {
       now_ms_ += frame_duration_ms + offset;
     }
-    EXPECT_EQ(kBwNormal, overuse_detector_->State());
+    EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
   }
   // Simulate a higher send pace, that is too high.
   // Total build up of 30 ms.
   for (int j = 0; j < 3; ++j) {
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     now_ms_ += frame_duration_ms + drift_per_frame_ms * 6;
     rtp_timestamp += frame_duration_ms * 90;
-    EXPECT_EQ(kBwNormal, overuse_detector_->State());
+    EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
   }
   UpdateDetector(rtp_timestamp, now_ms_, packet_size);
-  EXPECT_EQ(kBwOverusing, overuse_detector_->State());
+  EXPECT_EQ(BandwidthUsage::kBwOverusing, overuse_detector_->State());
 }
 
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_LowGaussianVariance30Kbit3fps \
   DISABLED_LowGaussianVariance30Kbit3fps
 #else
 #define MAYBE_LowGaussianVariance30Kbit3fps LowGaussianVariance30Kbit3fps
 #endif
 TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance30Kbit3fps) {
   size_t packet_size = 1200;
@@ skipping 336 matching lines @@
   double kTsDelta = 3000.0;
   int64_t now_ms = 0;
   int num_deltas = 60;
   const int kBatchLength = 10;
 
   // Pass in a positive offset and verify it triggers overuse.
   bool overuse_detected = false;
   for (int i = 0; i < kBatchLength; ++i) {
     BandwidthUsage overuse_state =
         overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms);
-    if (overuse_state == kBwOverusing) {
+    if (overuse_state == BandwidthUsage::kBwOverusing) {
       overuse_detected = true;
     }
     ++num_deltas;
     now_ms += 5;
   }
   EXPECT_TRUE(overuse_detected);
 
   // Force the threshold to increase by passing in a higher offset.
   overuse_detected = false;
   for (int i = 0; i < kBatchLength; ++i) {
     BandwidthUsage overuse_state =
         overuse_detector_->Detect(1.1 * kOffset, kTsDelta, num_deltas, now_ms);
-    if (overuse_state == kBwOverusing) {
+    if (overuse_state == BandwidthUsage::kBwOverusing) {
       overuse_detected = true;
     }
     ++num_deltas;
     now_ms += 5;
   }
   EXPECT_TRUE(overuse_detected);
 
   // Verify that the same offset as before no longer triggers overuse.
   overuse_detected = false;
   for (int i = 0; i < kBatchLength; ++i) {
     BandwidthUsage overuse_state =
         overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms);
-    if (overuse_state == kBwOverusing) {
+    if (overuse_state == BandwidthUsage::kBwOverusing) {
       overuse_detected = true;
     }
     ++num_deltas;
     now_ms += 5;
   }
   EXPECT_FALSE(overuse_detected);
 
   // Pass in a low offset to make the threshold adapt down.
   for (int i = 0; i < 15 * kBatchLength; ++i) {
     BandwidthUsage overuse_state =
         overuse_detector_->Detect(0.7 * kOffset, kTsDelta, num_deltas, now_ms);
-    if (overuse_state == kBwOverusing) {
+    if (overuse_state == BandwidthUsage::kBwOverusing) {
       overuse_detected = true;
     }
     ++num_deltas;
     now_ms += 5;
   }
   EXPECT_FALSE(overuse_detected);
 
   // Make sure the original offset now again triggers overuse.
   for (int i = 0; i < kBatchLength; ++i) {
     BandwidthUsage overuse_state =
         overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms);
-    if (overuse_state == kBwOverusing) {
+    if (overuse_state == BandwidthUsage::kBwOverusing) {
       overuse_detected = true;
     }
     ++num_deltas;
     now_ms += 5;
   }
   EXPECT_TRUE(overuse_detected);
 }
 
 TEST_F(OveruseDetectorExperimentTest, DoesntAdaptToSpikes) {
   const double kOffset = 1.0;
   const double kLargeOffset = 20.0;
   double kTsDelta = 3000.0;
   int64_t now_ms = 0;
   int num_deltas = 60;
   const int kBatchLength = 10;
   const int kShortBatchLength = 3;
 
   // Pass in a positive offset and verify it triggers overuse.
   bool overuse_detected = false;
   for (int i = 0; i < kBatchLength; ++i) {
     BandwidthUsage overuse_state =
         overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms);
-    if (overuse_state == kBwOverusing) {
+    if (overuse_state == BandwidthUsage::kBwOverusing) {
       overuse_detected = true;
     }
     ++num_deltas;
     now_ms += 5;
   }
 
   // Pass in a large offset. This shouldn't have a too big impact on the
   // threshold, but still trigger an overuse.
   now_ms += 100;
   overuse_detected = false;
   for (int i = 0; i < kShortBatchLength; ++i) {
     BandwidthUsage overuse_state =
         overuse_detector_->Detect(kLargeOffset, kTsDelta, num_deltas, now_ms);
-    if (overuse_state == kBwOverusing) {
+    if (overuse_state == BandwidthUsage::kBwOverusing) {
       overuse_detected = true;
     }
     ++num_deltas;
     now_ms += 5;
   }
   EXPECT_TRUE(overuse_detected);
 
   // Pass in a positive normal offset and verify it still triggers.
   overuse_detected = false;
   for (int i = 0; i < kBatchLength; ++i) {
     BandwidthUsage overuse_state =
         overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms);
-    if (overuse_state == kBwOverusing) {
+    if (overuse_state == BandwidthUsage::kBwOverusing) {
       overuse_detected = true;
     }
     ++num_deltas;
     now_ms += 5;
   }
   EXPECT_TRUE(overuse_detected);
 }
 }  // namespace testing
 }  // namespace webrtc