Create experiment for sparse BWE updates

webrtc/modules/congestion_controller/delay_based_bwe.cc

 /*
  *  Copyright (c) 2016 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 30 matching lines @@
 constexpr int kInitialRateWindowMs = 500;
 constexpr int kRateWindowMs = 150;
 
 // Parameters for linear least squares fit of regression line to noisy data.
 constexpr size_t kDefaultTrendlineWindowSize = 20;
 constexpr double kDefaultTrendlineSmoothingCoeff = 0.9;
 constexpr double kDefaultTrendlineThresholdGain = 4.0;
 
 constexpr int kMaxConsecutiveFailedLookups = 5;
 
+const char kBweSparseUpdateExperiment[] = "WebRTC-BweSparseUpdateExperiment";
+
+bool BweSparseUpdateExperimentIsEnabled() {
+  std::string experiment_string =

[michaelt, 2017/04/24 07:00:52]

nit:
how about use "experiment_status" instead of "experiment_string" ?

+      webrtc::field_trial::FindFullName(kBweSparseUpdateExperiment);
+  return experiment_string == "Enabled";
+}
 
 class PacketFeedbackComparator {
  public:
   inline bool operator()(const webrtc::PacketFeedback& lhs,
                          const webrtc::PacketFeedback& rhs) {
     if (lhs.arrival_time_ms != rhs.arrival_time_ms)
       return lhs.arrival_time_ms < rhs.arrival_time_ms;
     if (lhs.send_time_ms != rhs.send_time_ms)
       return lhs.send_time_ms < rhs.send_time_ms;
     return lhs.sequence_number < rhs.sequence_number;
@@ skipping 93 matching lines @@
       detector_(),
       receiver_incoming_bitrate_(),
       last_seen_packet_ms_(-1),
       uma_recorded_(false),
       probe_bitrate_estimator_(event_log),
       trendline_window_size_(kDefaultTrendlineWindowSize),
       trendline_smoothing_coeff_(kDefaultTrendlineSmoothingCoeff),
       trendline_threshold_gain_(kDefaultTrendlineThresholdGain),
       consecutive_delayed_feedbacks_(0),
       last_logged_bitrate_(0),
-      last_logged_state_(BandwidthUsage::kBwNormal) {
+      last_logged_state_(BandwidthUsage::kBwNormal),
+      in_sparse_update_experiment_(BweSparseUpdateExperimentIsEnabled()) {
   LOG(LS_INFO) << "Using Trendline filter for delay change estimation.";
-
   network_thread_.DetachFromThread();
 }
 
 DelayBasedBwe::Result DelayBasedBwe::IncomingPacketFeedbackVector(
     const std::vector<PacketFeedback>& packet_feedback_vector) {
   RTC_DCHECK(network_thread_.CalledOnValidThread());
 
   std::vector<PacketFeedback> sorted_packet_feedback_vector;
   SortPacketFeedbackVector(packet_feedback_vector,
                            &sorted_packet_feedback_vector);
@@ skipping 11 matching lines @@
                               BweNames::kBweNamesMax);
     uma_recorded_ = true;
   }
   bool overusing = false;
   bool delayed_feedback = true;
   for (const auto& packet_feedback : sorted_packet_feedback_vector) {
     if (packet_feedback.send_time_ms < 0)
       continue;
     delayed_feedback = false;
     IncomingPacketFeedback(packet_feedback);
-    overusing |= detector_.State() == BandwidthUsage::kBwOverusing;
+    if (!in_sparse_update_experiment_)
+      overusing |= (detector_.State() == BandwidthUsage::kBwOverusing);
   }
+  if (in_sparse_update_experiment_)
+    overusing = (detector_.State() == BandwidthUsage::kBwOverusing);
   if (delayed_feedback) {
     ++consecutive_delayed_feedbacks_;
     if (consecutive_delayed_feedbacks_ >= kMaxConsecutiveFailedLookups) {
       consecutive_delayed_feedbacks_ = 0;
       return OnLongFeedbackDelay(
           sorted_packet_feedback_vector.back().arrival_time_ms);
     }
   } else {
     consecutive_delayed_feedbacks_ = 0;
     return MaybeUpdateEstimate(overusing);
@@ skipping 145 matching lines @@
 void DelayBasedBwe::SetMinBitrate(int min_bitrate_bps) {
   // Called from both the configuration thread and the network thread. Shouldn't
   // be called from the network thread in the future.
   rate_control_.SetMinBitrate(min_bitrate_bps);
 }
 
 int64_t DelayBasedBwe::GetExpectedBwePeriodMs() const {
   return rate_control_.GetExpectedBandwidthPeriodMs();
 }
 }  // namespace webrtc