Landing Recent QUIC changes until 4/22/2016 14:55 UTC

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>
@@ skipping 51 matching lines @@
 const QuicPacketCount kMaxPacketsReceivedBeforeAckSend = 20;
 
 // Maximum number of retransmittable packets received before sending an ack.
 const QuicPacketCount kDefaultRetransmittablePacketsBeforeAck = 2;
 // Minimum number of packets received before ack decimation is enabled.
 // This intends to avoid the beginning of slow start, when CWNDs may be
 // rapidly increasing.
 const QuicPacketCount kMinReceivedBeforeAckDecimation = 100;
 // Wait for up to 10 retransmittable packets before sending an ack.
 const QuicPacketCount kMaxRetransmittablePacketsBeforeAck = 10;
+// One quarter RTT delay when doing ack decimation.
+const float kAckDecimationDelay = 0.25;
+// One eighth RTT delay when doing ack decimation.
+const float kShortAckDecimationDelay = 0.125;
 
 bool Near(QuicPacketNumber a, QuicPacketNumber b) {
   QuicPacketNumber delta = (a > b) ? a - b : b - a;
   return delta <= kMaxPacketGap;
 }
 
 bool IsInitializedIPEndPoint(const IPEndPoint& address) {
   return net::GetAddressFamily(address.address()) !=
          net::ADDRESS_FAMILY_UNSPECIFIED;
 }
@@ skipping 157 matching lines @@
       idle_timeout_connection_close_behavior_(
           ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET),
       close_connection_after_five_rtos_(false),
       received_packet_manager_(&stats_),
       ack_queued_(false),
       num_retransmittable_packets_received_since_last_ack_sent_(0),
       last_ack_had_missing_packets_(false),
       num_packets_received_since_last_ack_sent_(0),
       stop_waiting_count_(0),
       ack_mode_(TCP_ACKING),
+      ack_decimation_delay_(kAckDecimationDelay),
       delay_setting_retransmission_alarm_(false),
       pending_retransmission_alarm_(false),
       defer_send_in_response_to_packets_(false),
       arena_(),
       ack_alarm_(
           alarm_factory_->CreateAlarm(arena_.New<AckAlarm>(this), &arena_)),
       retransmission_alarm_(
           alarm_factory_->CreateAlarm(arena_.New<RetransmissionAlarm>(this),
                                       &arena_)),
       send_alarm_(
@@ skipping 106 matching lines @@
   }
   if (config.HasClientSentConnectionOption(kMTUL, perspective_)) {
     SetMtuDiscoveryTarget(kMtuDiscoveryTargetPacketSizeLow);
   }
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnSetFromConfig(config);
   }
   if (config.HasClientSentConnectionOption(kACKD, perspective_)) {
     ack_mode_ = ACK_DECIMATION;
   }
-  if (FLAGS_quic_ack_decimation2 &&
-      config.HasClientSentConnectionOption(kAKD2, perspective_)) {
+  if (config.HasClientSentConnectionOption(kAKD2, perspective_)) {
     ack_mode_ = ACK_DECIMATION_WITH_REORDERING;
   }
+  if (config.HasClientSentConnectionOption(kAKD3, perspective_)) {
+    ack_mode_ = ACK_DECIMATION;
+    ack_decimation_delay_ = kShortAckDecimationDelay;
+  }
+  if (config.HasClientSentConnectionOption(kAKD4, perspective_)) {
+    ack_mode_ = ACK_DECIMATION_WITH_REORDERING;
+    ack_decimation_delay_ = kShortAckDecimationDelay;
+  }
   if (FLAGS_quic_enable_rto_timeout &&
       config.HasClientSentConnectionOption(k5RTO, perspective_)) {
     close_connection_after_five_rtos_ = true;
   }
 }
 
 void QuicConnection::OnSendConnectionState(
     const CachedNetworkParameters& cached_network_params) {
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnSendConnectionState(cached_network_params);
@@ skipping 368 matching lines @@
   }
 
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnStopWaitingFrame(frame);
   }
 
   last_stop_waiting_frame_ = frame;
   return connected_;
 }
 
+bool QuicConnection::OnPaddingFrame(const QuicPaddingFrame& frame) {
+  DCHECK(connected_);
+  if (debug_visitor_ != nullptr) {
+    debug_visitor_->OnPaddingFrame(frame);
+  }
+  return true;
+}
+
 bool QuicConnection::OnPingFrame(const QuicPingFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnPingFrame(frame);
   }
   should_last_packet_instigate_acks_ = true;
   return true;
 }
 
 const char* QuicConnection::ValidateAckFrame(const QuicAckFrame& incoming_ack) {
@@ skipping 214 matching lines @@
     if (ack_mode_ != TCP_ACKING &&
         last_header_.packet_number > kMinReceivedBeforeAckDecimation) {
       // Ack up to 10 packets at once.
       if (num_retransmittable_packets_received_since_last_ack_sent_ >=
           kMaxRetransmittablePacketsBeforeAck) {
         ack_queued_ = true;
       } else if (!ack_alarm_->IsSet()) {
         // Wait the minimum of a quarter min_rtt and the delayed ack time.
         QuicTime::Delta ack_delay = QuicTime::Delta::Min(
             sent_packet_manager_.DelayedAckTime(),
-            sent_packet_manager_.GetRttStats()->min_rtt().Multiply(0.25));
+            sent_packet_manager_.GetRttStats()->min_rtt().Multiply(
+                ack_decimation_delay_));
         ack_alarm_->Set(clock_->ApproximateNow().Add(ack_delay));
       }
     } else {
       // Ack with a timer or every 2 packets by default.
       if (num_retransmittable_packets_received_since_last_ack_sent_ >=
           kDefaultRetransmittablePacketsBeforeAck) {
         ack_queued_ = true;
       } else if (!ack_alarm_->IsSet()) {
         ack_alarm_->Set(clock_->ApproximateNow().Add(
             sent_packet_manager_.DelayedAckTime()));
@@ skipping 771 matching lines @@
   ack_queued_ = false;
   stop_waiting_count_ = 0;
   num_retransmittable_packets_received_since_last_ack_sent_ = 0;
   last_ack_had_missing_packets_ = received_packet_manager_.HasMissingPackets();
   num_packets_received_since_last_ack_sent_ = 0;
 
   packet_generator_.SetShouldSendAck(true);
 }
 
 void QuicConnection::OnRetransmissionTimeout() {
-  if (!sent_packet_manager_.HasUnackedPackets()) {
-    return;
+  if (FLAGS_quic_always_has_unacked_packets_on_timeout) {
+    DCHECK(sent_packet_manager_.HasUnackedPackets());
+  } else {
+    if (!sent_packet_manager_.HasUnackedPackets()) {
+      return;
+    }
   }
 
   if (close_connection_after_five_rtos_ &&
       sent_packet_manager_.consecutive_rto_count() >= 4) {
     // Close on the 5th consecutive RTO, so after 4 previous RTOs have occurred.
     CloseConnection(QUIC_TOO_MANY_RTOS, "5 consecutive retransmission timeouts",
                     ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return;
   }
 
@@ skipping 557 matching lines @@
 }
 
 StringPiece QuicConnection::GetCurrentPacket() {
   if (current_packet_data_ == nullptr) {
     return StringPiece();
   }
   return StringPiece(current_packet_data_, last_size_);
 }
 
 }  // namespace net