Resolve dependency between rtc_event_log_api and remote_bitrate_estimator

webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.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 107 matching lines @@
   if (estimator->inter_arrival.ComputeDeltas(
           rtp_timestamp, arrival_time_ms, now_ms, payload_size,
           &timestamp_delta, &time_delta, &size_delta)) {
     double timestamp_delta_ms = timestamp_delta * kTimestampToMs;
     estimator->estimator.Update(time_delta, timestamp_delta_ms, size_delta,
                                 estimator->detector.State(), now_ms);
     estimator->detector.Detect(estimator->estimator.offset(),
                                timestamp_delta_ms,
                                estimator->estimator.num_of_deltas(), now_ms);
   }
-  if (estimator->detector.State() == kBwOverusing) {
+  if (estimator->detector.State() == BandwidthUsage::kBwOverusing) {
     rtc::Optional<uint32_t> incoming_bitrate_bps =
         incoming_bitrate_.Rate(now_ms);
     if (incoming_bitrate_bps &&
-        (prior_state != kBwOverusing ||
+        (prior_state != BandwidthUsage::kBwOverusing ||
          GetRemoteRate()->TimeToReduceFurther(now_ms, *incoming_bitrate_bps))) {
       // The first overuse should immediately trigger a new estimate.
       // We also have to update the estimate immediately if we are overusing
       // and the target bitrate is too high compared to what we are receiving.
       UpdateEstimate(now_ms);
     }
   }
 }
 
 void RemoteBitrateEstimatorSingleStream::Process() {
   {
     rtc::CritScope cs(&crit_sect_);
     UpdateEstimate(clock_->TimeInMilliseconds());
   }
   last_process_time_ = clock_->TimeInMilliseconds();
 }
 
 int64_t RemoteBitrateEstimatorSingleStream::TimeUntilNextProcess() {
   if (last_process_time_ < 0) {
     return 0;
   }
   rtc::CritScope cs_(&crit_sect_);
   RTC_DCHECK_GT(process_interval_ms_, 0);
   return last_process_time_ + process_interval_ms_ -
       clock_->TimeInMilliseconds();
 }
 
 void RemoteBitrateEstimatorSingleStream::UpdateEstimate(int64_t now_ms) {
-  BandwidthUsage bw_state = kBwNormal;
+  BandwidthUsage bw_state = BandwidthUsage::kBwNormal;
   double sum_var_noise = 0.0;
   SsrcOveruseEstimatorMap::iterator it = overuse_detectors_.begin();
   while (it != overuse_detectors_.end()) {
     const int64_t time_of_last_received_packet =
         it->second->last_packet_time_ms;
     if (time_of_last_received_packet >= 0 &&
         now_ms - time_of_last_received_packet > kStreamTimeOutMs) {
       // This over-use detector hasn't received packets for |kStreamTimeOutMs|
       // milliseconds and is considered stale.
       delete it->second;
@@ skipping 77 matching lines @@
     remote_rate_.reset(new AimdRateControl());
   return remote_rate_.get();
 }
 
 void RemoteBitrateEstimatorSingleStream::SetMinBitrate(int min_bitrate_bps) {
   rtc::CritScope cs(&crit_sect_);
   remote_rate_->SetMinBitrate(min_bitrate_bps);
 }
 
 }  // namespace webrtc