Land Recent QUIC Changes.

net/quic/congestion_control/tcp_cubic_sender.cc

 // Copyright (c) 2012 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/congestion_control/tcp_cubic_sender.h"
 
 #include <algorithm>
 
 #include "base/metrics/histogram.h"
 
@@ skipping 71 matching lines @@
         feedback.tcp.accumulated_number_of_lost_packets;
     if (recovered_lost_packets > 0) {
       // Assume the loss could be as late as the last acked packet.
       OnPacketLost(largest_acked_sequence_number_, feedback_receive_time);
     }
   }
   receive_window_ = feedback.tcp.receive_window;
 }
 
 void TcpCubicSender::OnPacketAcked(
-    QuicPacketSequenceNumber acked_sequence_number,
-    QuicByteCount acked_bytes,
-    QuicTime::Delta rtt) {
+    QuicPacketSequenceNumber acked_sequence_number, QuicByteCount acked_bytes) {
   DCHECK_GE(bytes_in_flight_, acked_bytes);
   bytes_in_flight_ -= acked_bytes;
   largest_acked_sequence_number_ = max(acked_sequence_number,
                                        largest_acked_sequence_number_);
   CongestionAvoidance(acked_sequence_number);
-  AckAccounting(rtt);
   if (end_sequence_number_ == acked_sequence_number) {
     DVLOG(1) << "Start update end sequence number @" << acked_sequence_number;
     update_end_sequence_number_ = true;
   }
 }
 
 void TcpCubicSender::OnPacketLost(QuicPacketSequenceNumber sequence_number,
                                   QuicTime /*ack_receive_time*/) {
   // TCP NewReno (RFC6582) says that once a loss occurs, any losses in packets
   // already sent should be treated as a single loss event, since it's expected.
@@ skipping 168 matching lines @@
 }
 
 void TcpCubicSender::OnRetransmissionTimeout(bool packets_retransmitted) {
   bytes_in_flight_ = 0;
   if (packets_retransmitted) {
     cubic_.Reset();
     congestion_window_ = kMinimumCongestionWindow;
   }
 }
 
-void TcpCubicSender::AckAccounting(QuicTime::Delta rtt) {
+void TcpCubicSender::UpdateRtt(QuicTime::Delta rtt) {
   if (rtt.IsInfinite() || rtt.IsZero()) {
     DVLOG(1) << "Ignoring rtt, because it's "
                << (rtt.IsZero() ? "Zero" : "Infinite");
     return;
   }
   // RTT can't be negative.
   DCHECK_LT(0, rtt.ToMicroseconds());
 
   // TODO(pwestin): Discard delay samples right after fast recovery,
   // during 1 second?.
@@ skipping 26 matching lines @@
       hybrid_slow_start_.Reset(end_sequence_number_);
     }
     hybrid_slow_start_.Update(rtt, delay_min_);
     if (hybrid_slow_start_.Exit()) {
       slowstart_threshold_ = congestion_window_;
     }
   }
 }
 
 }  // namespace net