Revert of Make the acceptable queue in the cwnd experiment configurable.

webrtc/modules/congestion_controller/send_side_congestion_controller.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.
  */
 
 #include "webrtc/modules/congestion_controller/include/send_side_congestion_controller.h"
 
 #include <algorithm>
 #include <memory>
 #include <vector>
 
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/congestion_controller/acknowledged_bitrate_estimator.h"
 #include "webrtc/modules/congestion_controller/probe_controller.h"
 #include "webrtc/modules/pacing/alr_detector.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
 #include "webrtc/rtc_base/checks.h"
-#include "webrtc/rtc_base/format_macros.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/rtc_base/ptr_util.h"
 #include "webrtc/rtc_base/rate_limiter.h"
 #include "webrtc/rtc_base/socket.h"
 #include "webrtc/rtc_base/timeutils.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 
 namespace webrtc {
 namespace {
 
 const char kCwndExperiment[] = "WebRTC-CwndExperiment";
-const int64_t kDefaultAcceptedQueueMs = 250;
 
 bool CwndExperimentEnabled() {
   std::string experiment_string =
       webrtc::field_trial::FindFullName(kCwndExperiment);
   // The experiment is enabled iff the field trial string begins with "Enabled".
   return experiment_string.find("Enabled") == 0;
 }
 
-bool ReadCwndExperimentParameter(int64_t* accepted_queue_ms) {
-  RTC_DCHECK(accepted_queue_ms);
-  std::string experiment_string =
-      webrtc::field_trial::FindFullName(kCwndExperiment);
-  int parsed_values =
-      sscanf(experiment_string.c_str(), "Enabled-%" PRId64, accepted_queue_ms);
-  if (parsed_values == 1) {
-    RTC_CHECK_GE(*accepted_queue_ms, 0)
-        << "Accepted must be greater than or equal to 0.";
-    return true;
-  }
-  return false;
-}
-
 static const int64_t kRetransmitWindowSizeMs = 500;
 
 // Makes sure that the bitrate and the min, max values are in valid range.
 static void ClampBitrates(int* bitrate_bps,
                           int* min_bitrate_bps,
                           int* max_bitrate_bps) {
   // TODO(holmer): We should make sure the default bitrates are set to 10 kbps,
   // and that we don't try to set the min bitrate to 0 from any applications.
   // The congestion controller should allow a min bitrate of 0.
   if (*min_bitrate_bps < congestion_controller::GetMinBitrateBps())
@@ skipping 56 matching lines @@
       transport_feedback_adapter_(clock_),
       last_reported_bitrate_bps_(0),
       last_reported_fraction_loss_(0),
       last_reported_rtt_(0),
       network_state_(kNetworkUp),
       pause_pacer_(false),
       pacer_paused_(false),
       min_bitrate_bps_(congestion_controller::GetMinBitrateBps()),
       delay_based_bwe_(new DelayBasedBwe(event_log_, clock_)),
       in_cwnd_experiment_(CwndExperimentEnabled()),
-      accepted_queue_ms_(kDefaultAcceptedQueueMs),
       was_in_alr_(0) {
   delay_based_bwe_->SetMinBitrate(min_bitrate_bps_);
-  if (in_cwnd_experiment_ &&
-      !ReadCwndExperimentParameter(&accepted_queue_ms_)) {
-    LOG(LS_WARNING) << "Failed to parse parameters for CwndExperiment "
-                       "from field trial string. Experiment disabled.";
-    in_cwnd_experiment_ = false;
-  }
 }
 
 SendSideCongestionController::~SendSideCongestionController() {}
 
 void SendSideCongestionController::RegisterPacketFeedbackObserver(
     PacketFeedbackObserver* observer) {
   transport_feedback_adapter_.RegisterPacketFeedbackObserver(observer);
 }
 
 void SendSideCongestionController::DeRegisterPacketFeedbackObserver(
@@ skipping 207 matching lines @@
   if (!in_cwnd_experiment_)
     return;
   {
     rtc::CritScope lock(&network_state_lock_);
     rtc::Optional<int64_t> min_rtt_ms =
         transport_feedback_adapter_.GetMinFeedbackLoopRtt();
     // No valid RTT. Could be because send-side BWE isn't used, in which case
     // we don't try to limit the outstanding packets.
     if (!min_rtt_ms)
       return;
+    const int64_t kAcceptedQueueMs = 250;
     const size_t kMinCwndBytes = 2 * 1500;
     size_t max_outstanding_bytes =
-        std::max<size_t>((*min_rtt_ms + accepted_queue_ms_) *
+        std::max<size_t>((*min_rtt_ms + kAcceptedQueueMs) *
                              last_reported_bitrate_bps_ / 1000 / 8,
                          kMinCwndBytes);
     LOG(LS_INFO) << clock_->TimeInMilliseconds()
                  << " Outstanding bytes: " << num_outstanding_bytes
                  << " pacer queue: " << pacer_->QueueInMs()
                  << " max outstanding: " << max_outstanding_bytes;
     LOG(LS_INFO) << "Feedback rtt: " << *min_rtt_ms
                  << " Bitrate: " << last_reported_bitrate_bps_;
     pause_pacer_ = num_outstanding_bytes > max_outstanding_bytes;
   }
@@ skipping 57 matching lines @@
 bool SendSideCongestionController::IsSendQueueFull() const {
   return pacer_->ExpectedQueueTimeMs() > PacedSender::kMaxQueueLengthMs;
 }
 
 bool SendSideCongestionController::IsNetworkDown() const {
   rtc::CritScope cs(&network_state_lock_);
   return network_state_ == kNetworkDown;
 }
 
 }  // namespace webrtc