Landing Recent QUIC changes until May 20, 2017.

net/quic/core/congestion_control/bbr_sender.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/core/congestion_control/bbr_sender.h"
 
 #include <algorithm>
 #include <sstream>
 
 #include "net/quic/core/congestion_control/rtt_stats.h"
@@ skipping 515 matching lines @@
   // Exit recovery when there are no losses for a round.
   if (has_losses) {
     end_recovery_at_ = last_sent_packet_;
   }
 
   switch (recovery_state_) {
     case NOT_IN_RECOVERY:
       // Enter conservation on the first loss.
       if (has_losses) {
         recovery_state_ = CONSERVATION;
-        if (FLAGS_quic_reloadable_flag_quic_bbr_fix_conservation ||
-            FLAGS_quic_reloadable_flag_quic_bbr_fix_conservation2) {
+        if (FLAGS_quic_reloadable_flag_quic_bbr_fix_conservation2) {
           // This will cause the |recovery_window_| to be set to the correct
           // value in CalculateRecoveryWindow().
           recovery_window_ = 0;
-          QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_fix_conservation, 1,
-                            3);
           QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_fix_conservation2, 1,
                             3);
         }
         // Since the conservation phase is meant to be lasting for a whole
         // round, extend the current round as if it were started right now.
         current_round_trip_end_ = last_sent_packet_;
       }
       break;
 
     case CONSERVATION:
@@ skipping 178 matching lines @@
     // Sanity checks.  Ensure that we always allow to send at least
     // |bytes_acked| in response.
     recovery_window_ = std::max(
         recovery_window_, unacked_packets_->bytes_in_flight() + bytes_acked);
     recovery_window_ = std::max(kMinimumCongestionWindow, recovery_window_);
     return;
   }
 
   switch (recovery_state_) {
     case CONSERVATION:
-      if (FLAGS_quic_reloadable_flag_quic_bbr_fix_conservation) {
-        QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_fix_conservation, 2, 3);
-        recovery_window_ =
-            std::max(unacked_packets_->bytes_in_flight() + bytes_acked,
-                     recovery_window_);
-      } else {
-        recovery_window_ = unacked_packets_->bytes_in_flight() + bytes_acked;
-      }
+      recovery_window_ = unacked_packets_->bytes_in_flight() + bytes_acked;
       break;
     case GROWTH:
-      if (FLAGS_quic_reloadable_flag_quic_bbr_fix_conservation) {
-        QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_fix_conservation, 3, 3);
-        recovery_window_ =
-            std::max(unacked_packets_->bytes_in_flight() + 2 * bytes_acked,
-                     recovery_window_ + bytes_acked);
-      } else {
-        recovery_window_ =
-            unacked_packets_->bytes_in_flight() + 2 * bytes_acked;
-      }
+      recovery_window_ = unacked_packets_->bytes_in_flight() + 2 * bytes_acked;
       break;
     default:
       break;
   }
   recovery_window_ = std::max(kMinimumCongestionWindow, recovery_window_);
 }
 
 std::string BbrSender::GetDebugState() const {
   std::ostringstream stream;
   stream << ExportDebugState();
@@ skipping 53 matching lines @@
   os << "Minimum RTT timestamp: " << state.min_rtt_timestamp.ToDebuggingValue()
      << std::endl;
 
   os << "Last sample is app-limited: "
      << (state.last_sample_is_app_limited ? "yes" : "no");
 
   return os;
 }
 
 }  // namespace net