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"
 
 namespace net {
 
 namespace {
 // Constants based on TCP defaults.
@@ skipping 47 matching lines @@
     if (recovered_lost_packets > 0) {
       OnIncomingLoss(feedback_receive_time);
     }
   }
   receiver_congestion_window_ = feedback.tcp.receive_window;
 }
 
 void TcpCubicSender::OnIncomingAck(
     QuicPacketSequenceNumber acked_sequence_number, QuicByteCount acked_bytes,
     QuicTime::Delta rtt) {
+  DCHECK_GE(bytes_in_flight_, acked_bytes);
   bytes_in_flight_ -= acked_bytes;
   CongestionAvoidance(acked_sequence_number);
   AckAccounting(rtt);
   if (end_sequence_number_ == acked_sequence_number) {
     DLOG(INFO) << "Start update end sequence number @" << acked_sequence_number;
     update_end_sequence_number_ = true;
   }
 }
 
 void TcpCubicSender::OnIncomingLoss(QuicTime /*ack_receive_time*/) {
   // In a normal TCP we would need to know the lowest missing packet to detect
   // if we receive 3 missing packets. Here we get a missing packet for which we
   // enter TCP Fast Retransmit immediately.
   if (reno_) {
     congestion_window_ = congestion_window_ >> 1;
     slowstart_threshold_ = congestion_window_;
   } else {
     congestion_window_ =
         cubic_.CongestionWindowAfterPacketLoss(congestion_window_);
     slowstart_threshold_ = congestion_window_;
   }
   // Sanity, make sure that we don't end up with an empty window.
   if (congestion_window_ == 0) {
     congestion_window_ = 1;
   }
   DLOG(INFO) << "Incoming loss; congestion window:" << congestion_window_;
 }
 
-void TcpCubicSender::SentPacket(QuicTime /*sent_time*/,
+bool TcpCubicSender::SentPacket(QuicTime /*sent_time*/,
                                 QuicPacketSequenceNumber sequence_number,
                                 QuicByteCount bytes,
-                                Retransmission is_retransmission) {
+                                Retransmission is_retransmission,
+                                HasRetransmittableData is_retransmittable) {
+  // Only update bytes_in_flight_ for data packets.
+  if (is_retransmittable != HAS_RETRANSMITTABLE_DATA) {
+    return false;
+  }
+
   bytes_in_flight_ += bytes;
   if (is_retransmission == NOT_RETRANSMISSION && update_end_sequence_number_) {
     end_sequence_number_ = sequence_number;
     if (AvailableCongestionWindow() == 0) {
       update_end_sequence_number_ = false;
       DLOG(INFO) << "Stop update end sequence number @" << sequence_number;
     }
   }
+  return true;
 }
 
 void TcpCubicSender::AbandoningPacket(QuicPacketSequenceNumber sequence_number,
                                       QuicByteCount abandoned_bytes) {
+  DCHECK_GE(bytes_in_flight_, abandoned_bytes);
   bytes_in_flight_ -= abandoned_bytes;
 }
 
 QuicTime::Delta TcpCubicSender::TimeUntilSend(
     QuicTime now,
     Retransmission is_retransmission,
     HasRetransmittableData has_retransmittable_data,
     IsHandshake handshake) {
   if (is_retransmission == IS_RETRANSMISSION ||
       has_retransmittable_data == NO_RETRANSMITTABLE_DATA ||
@@ skipping 141 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