Land Recent QUIC Changes.

net/quic/quic_connection.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/quic_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 #include <algorithm>
 #include <iterator>
@@ skipping 273 matching lines @@
 
   return false;
 }
 
 void QuicConnection::OnError(QuicFramer* framer) {
   // Packets that we cannot decrypt are dropped.
   // TODO(rch): add stats to measure this.
   if (!connected_ || framer->error() == QUIC_DECRYPTION_FAILURE) {
     return;
   }
-  SendConnectionClose(framer->error());
+  SendConnectionCloseWithDetails(framer->error(), framer->detailed_error());
 }
 
 void QuicConnection::OnPacket() {
   DCHECK(last_stream_frames_.empty() &&
          last_goaway_frames_.empty() &&
          last_rst_frames_.empty() &&
          last_ack_frames_.empty() &&
          last_congestion_frames_.empty());
 }
 
@@ skipping 237 matching lines @@
   sent_packet_manager_.OnIncomingAck(incoming_ack.received_info,
                                      received_truncated_ack_);
 
   // Get the updated least unacked sequence number.
   QuicPacketSequenceNumber least_unacked_sent_after =
       sent_packet_manager_.GetLeastUnackedSentPacket();
 
   // Used to set RTO and FEC alarms.
   QuicTime::Delta retransmission_delay =
       congestion_manager_.GetRetransmissionDelay(
-          sent_packet_manager_.GetNumUnackedPackets(), 0);
+          sent_packet_manager_.GetNumRetransmittablePackets(), 0);
 
   // If there are outstanding packets, and the least unacked sequence number
   // has increased after processing this latest AckFrame, then reschedule the
   // retransmission timer.
   if (sent_packet_manager_.HasUnackedPackets() &&
       least_unacked_sent_before < least_unacked_sent_after) {
     if (retransmission_alarm_->IsSet()) {
       retransmission_alarm_->Cancel();
     }
     retransmission_alarm_->Set(
@@ skipping 629 matching lines @@
   }
 
   // Do not set the retransmission alarm if we're already handling one, since
   // it will be reset when OnRetransmissionTimeout completes.
   if (retransmission_alarm_->IsSet()) {
     return;
   }
 
   QuicTime::Delta retransmission_delay =
       congestion_manager_.GetRetransmissionDelay(
-          sent_packet_manager_.GetNumUnackedPackets(), consecutive_rto_count_);
+          sent_packet_manager_.GetNumRetransmittablePackets(),
+          consecutive_rto_count_);
   retransmission_alarm_->Set(
       clock_->ApproximateNow().Add(retransmission_delay));
 }
 
 void QuicConnection::SetupAbandonFecTimer(
     QuicPacketSequenceNumber sequence_number) {
   if (abandon_fec_alarm_->IsSet()) {
     return;
   }
   QuicTime::Delta retransmission_delay =
       congestion_manager_.GetRetransmissionDelay(
-          sent_packet_manager_.GetNumUnackedPackets(), consecutive_rto_count_);
+          sent_packet_manager_.GetNumRetransmittablePackets(),
+          consecutive_rto_count_);
   abandon_fec_alarm_->Set(clock_->ApproximateNow().Add(retransmission_delay));
 }
 
 bool QuicConnection::WritePacket(EncryptionLevel level,
                                  QuicPacketSequenceNumber sequence_number,
                                  QuicPacket* packet,
                                  TransmissionType transmission_type,
                                  HasRetransmittableData retransmittable,
                                  IsHandshake handshake,
                                  Force forced) {
@@ skipping 328 matching lines @@
   if (!retransmission_alarm_->IsSet()) {
     WriteIfNotBlocked();
   }
 }
 
 QuicTime QuicConnection::OnAbandonFecTimeout() {
   // Abandon all the FEC packets older than the current RTO, then reschedule
   // the alarm if there are more pending fec packets.
   QuicTime::Delta retransmission_delay =
       congestion_manager_.GetRetransmissionDelay(
-          sent_packet_manager_.GetNumUnackedPackets(), consecutive_rto_count_);
+          sent_packet_manager_.GetNumRetransmittablePackets(),
+          consecutive_rto_count_);
   QuicTime max_send_time =
       clock_->ApproximateNow().Subtract(retransmission_delay);
   bool abandoned_packet = false;
   while (sent_packet_manager_.HasUnackedFecPackets()) {
     QuicPacketSequenceNumber oldest_unacked_fec =
         sent_packet_manager_.GetLeastUnackedFecPacket();
     QuicTime fec_sent_time =
         sent_packet_manager_.GetFecSentTime(oldest_unacked_fec);
     if (fec_sent_time > max_send_time) {
       return fec_sent_time.Add(retransmission_delay);
@@ skipping 277 matching lines @@
     QuicConnection* connection,
     bool include_ack)
     : connection_(connection),
       already_in_batch_mode_(connection->packet_generator_.InBatchMode()) {
   // Move generator into batch mode. If caller wants us to include an ack,
   // check the delayed-ack timer to see if there's ack info to be sent.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Entering Batch Mode.";
     connection_->packet_generator_.StartBatchOperations();
   }
-  if (FLAGS_bundle_ack_with_outgoing_packet &&
-      include_ack && connection_->ack_alarm_->IsSet()) {
+  if (include_ack && connection_->ack_alarm_->IsSet()) {
     DVLOG(1) << "Bundling ack with outgoing packet.";
     connection_->SendAck();
   }
 }
 
 QuicConnection::ScopedPacketBundler::~ScopedPacketBundler() {
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
   }
   DCHECK_EQ(already_in_batch_mode_,
             connection_->packet_generator_.InBatchMode());
 }
 
 }  // namespace net