Landing Recent QUIC changes until Fri Nov 18 23:21:04 2016 +0000

net/quic/core/quic_sent_packet_manager.cc

 // Copyright 2013 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/quic_sent_packet_manager.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 27 matching lines @@
 // This limits the tenth retransmitted packet to 10s after the initial CHLO.
 static const int64_t kMinHandshakeTimeoutMs = 10;
 
 // Ensure the handshake timer isnt't faster than 25ms.
 static const int64_t kConservativeMinHandshakeTimeoutMs = kMaxDelayedAckTimeMs;
 
 // Sends up to two tail loss probes before firing an RTO,
 // per draft RFC draft-dukkipati-tcpm-tcp-loss-probe.
 static const size_t kDefaultMaxTailLossProbes = 2;
 
-bool HasCryptoHandshake(const TransmissionInfo& transmission_info) {
+bool HasCryptoHandshake(const QuicTransmissionInfo& transmission_info) {
   DCHECK(!transmission_info.has_crypto_handshake ||
          !transmission_info.retransmittable_frames.empty());
   return transmission_info.has_crypto_handshake;
 }
 
 }  // namespace
 
 #define ENDPOINT \
   (perspective_ == Perspective::IS_SERVER ? "Server: " : "Client: ")
 
@@ skipping 45 matching lines @@
         max(kMinInitialRoundTripTimeUs,
             min(kMaxInitialRoundTripTimeUs,
                 config.ReceivedInitialRoundTripTimeUs())));
   } else if (config.HasInitialRoundTripTimeUsToSend() &&
              config.GetInitialRoundTripTimeUsToSend() > 0) {
     rtt_stats_.set_initial_rtt_us(
         max(kMinInitialRoundTripTimeUs,
             min(kMaxInitialRoundTripTimeUs,
                 config.GetInitialRoundTripTimeUsToSend())));
   }
-  if (FLAGS_quic_allow_new_bbr && config.HasReceivedConnectionOptions() &&
-      ContainsQuicTag(config.ReceivedConnectionOptions(), kTBBR)) {
-    SetSendAlgorithm(kBBR);
-  }
-  if (config.HasReceivedConnectionOptions() &&
-      ContainsQuicTag(config.ReceivedConnectionOptions(), kRENO)) {
-    if (ContainsQuicTag(config.ReceivedConnectionOptions(), kBYTE)) {
-      SetSendAlgorithm(kRenoBytes);
-    } else {
-      SetSendAlgorithm(kReno);
+  // Configure congestion control.
+  const bool enable_client_connection_options =
+      FLAGS_quic_client_connection_options;
+  if (enable_client_connection_options) {
+    if (FLAGS_quic_allow_new_bbr &&
+        config.HasClientRequestedIndependentOption(kTBBR, perspective_)) {
+      SetSendAlgorithm(kBBR);
     }
-  } else if (config.HasReceivedConnectionOptions() &&
-             ContainsQuicTag(config.ReceivedConnectionOptions(), kBYTE)) {
-    if (FLAGS_quic_default_enable_cubic_bytes) {
-      SetSendAlgorithm(kCubic);
-    } else {
-      SetSendAlgorithm(kCubicBytes);
+    if (config.HasClientRequestedIndependentOption(kRENO, perspective_)) {
+      if (config.HasClientRequestedIndependentOption(kBYTE, perspective_)) {
+        SetSendAlgorithm(kRenoBytes);
+      } else {
+        SetSendAlgorithm(kReno);
+      }
+    } else if (config.HasClientRequestedIndependentOption(kBYTE,
+                                                          perspective_)) {
+      if (FLAGS_quic_default_enable_cubic_bytes) {
+        SetSendAlgorithm(kCubic);
+      } else {
+        SetSendAlgorithm(kCubicBytes);
+      }
+    }
+  } else {
+    if (FLAGS_quic_allow_new_bbr && config.HasReceivedConnectionOptions() &&
+        ContainsQuicTag(config.ReceivedConnectionOptions(), kTBBR)) {
+      SetSendAlgorithm(kBBR);
+    }
+    if (config.HasReceivedConnectionOptions() &&
+        ContainsQuicTag(config.ReceivedConnectionOptions(), kRENO)) {
+      if (ContainsQuicTag(config.ReceivedConnectionOptions(), kBYTE)) {
+        SetSendAlgorithm(kRenoBytes);
+      } else {
+        SetSendAlgorithm(kReno);
+      }
+    } else if (config.HasReceivedConnectionOptions() &&
+               ContainsQuicTag(config.ReceivedConnectionOptions(), kBYTE)) {
+      if (FLAGS_quic_default_enable_cubic_bytes) {
+        SetSendAlgorithm(kCubic);
+      } else {
+        SetSendAlgorithm(kCubicBytes);
+      }
     }
   }
   using_pacing_ = !FLAGS_quic_disable_pacing_for_perf_tests;
 
   if (config.HasClientSentConnectionOption(k1CON, perspective_)) {
     send_algorithm_->SetNumEmulatedConnections(1);
   }
   if (config.HasClientSentConnectionOption(kNCON, perspective_)) {
     n_connection_simulation_ = true;
   }
   if (config.HasClientSentConnectionOption(kNTLP, perspective_)) {
     max_tail_loss_probes_ = 0;
   }
   if (config.HasClientSentConnectionOption(kTLPR, perspective_)) {
     enable_half_rtt_tail_loss_probe_ = true;
   }
   if (config.HasClientSentConnectionOption(kNRTO, perspective_)) {
     use_new_rto_ = true;
   }
-  if (config.HasReceivedConnectionOptions() &&
-      ContainsQuicTag(config.ReceivedConnectionOptions(), kTIME)) {
-    general_loss_algorithm_.SetLossDetectionType(kTime);
-  }
-  if (config.HasReceivedConnectionOptions() &&
-      ContainsQuicTag(config.ReceivedConnectionOptions(), kATIM)) {
-    general_loss_algorithm_.SetLossDetectionType(kAdaptiveTime);
-  }
-  if (FLAGS_quic_enable_lazy_fack && config.HasReceivedConnectionOptions() &&
-      ContainsQuicTag(config.ReceivedConnectionOptions(), kLFAK)) {
-    general_loss_algorithm_.SetLossDetectionType(kLazyFack);
+  // Configure loss detection.
+  if (enable_client_connection_options) {
+    if (config.HasClientRequestedIndependentOption(kTIME, perspective_)) {
+      general_loss_algorithm_.SetLossDetectionType(kTime);
+    }
+    if (config.HasClientRequestedIndependentOption(kATIM, perspective_)) {
+      general_loss_algorithm_.SetLossDetectionType(kAdaptiveTime);
+    }
+    if (FLAGS_quic_enable_lazy_fack &&
+        config.HasClientRequestedIndependentOption(kLFAK, perspective_)) {
+      general_loss_algorithm_.SetLossDetectionType(kLazyFack);
+    }
+  } else {
+    if (config.HasReceivedConnectionOptions() &&
+        ContainsQuicTag(config.ReceivedConnectionOptions(), kTIME)) {
+      general_loss_algorithm_.SetLossDetectionType(kTime);
+    }
+    if (config.HasReceivedConnectionOptions() &&
+        ContainsQuicTag(config.ReceivedConnectionOptions(), kATIM)) {
+      general_loss_algorithm_.SetLossDetectionType(kAdaptiveTime);
+    }
+    if (FLAGS_quic_enable_lazy_fack && config.HasReceivedConnectionOptions() &&
+        ContainsQuicTag(config.ReceivedConnectionOptions(), kLFAK)) {
+      general_loss_algorithm_.SetLossDetectionType(kLazyFack);
+    }
   }
   if (config.HasClientSentConnectionOption(kUNDO, perspective_)) {
     undo_pending_retransmits_ = true;
   }
   if (FLAGS_quic_conservative_handshake_retransmits &&
       config.HasClientSentConnectionOption(kCONH, perspective_)) {
     conservative_handshake_retransmits_ = true;
   }
   send_algorithm_->SetFromConfig(config, perspective_);
 
@@ skipping 188 matching lines @@
       }
       unacked_packets_.RemoveFromInFlight(packet_number);
       unacked_packets_.RemoveRetransmittability(packet_number);
     }
   }
 }
 
 void QuicSentPacketManager::MarkForRetransmission(
     QuicPacketNumber packet_number,
     TransmissionType transmission_type) {
-  const TransmissionInfo& transmission_info =
+  const QuicTransmissionInfo& transmission_info =
       unacked_packets_.GetTransmissionInfo(packet_number);
   QUIC_BUG_IF(transmission_info.retransmittable_frames.empty());
   // Both TLP and the new RTO leave the packets in flight and let the loss
   // detection decide if packets are lost.
   if (transmission_type != TLP_RETRANSMISSION &&
       transmission_type != RTO_RETRANSMISSION) {
     unacked_packets_.RemoveFromInFlight(packet_number);
   }
   if (delegate_ != nullptr) {
     delegate_->OnRetransmissionMarked(path_id_, packet_number,
                                       transmission_type);
   } else {
     // TODO(ianswett): Currently the RTO can fire while there are pending NACK
     // retransmissions for the same data, which is not ideal.
     if (base::ContainsKey(pending_retransmissions_, packet_number)) {
       return;
     }
 
     pending_retransmissions_[packet_number] = transmission_type;
   }
 }
 
 void QuicSentPacketManager::RecordOneSpuriousRetransmission(
-    const TransmissionInfo& info) {
+    const QuicTransmissionInfo& info) {
   stats_->bytes_spuriously_retransmitted += info.bytes_sent;
   ++stats_->packets_spuriously_retransmitted;
   if (debug_delegate_ != nullptr) {
     debug_delegate_->OnSpuriousPacketRetransmission(info.transmission_type,
                                                     info.bytes_sent);
   }
 }
 
 void QuicSentPacketManager::RecordSpuriousRetransmissions(
-    const TransmissionInfo& info,
+    const QuicTransmissionInfo& info,
     QuicPacketNumber acked_packet_number) {
   QuicPacketNumber retransmission = info.retransmission;
   while (retransmission != 0) {
-    const TransmissionInfo& retransmit_info =
+    const QuicTransmissionInfo& retransmit_info =
         unacked_packets_.GetTransmissionInfo(retransmission);
     retransmission = retransmit_info.retransmission;
     RecordOneSpuriousRetransmission(retransmit_info);
   }
   // Only inform the loss detection of spurious retransmits it caused.
   if (unacked_packets_.GetTransmissionInfo(info.retransmission)
           .transmission_type == LOSS_RETRANSMISSION) {
     loss_algorithm_->SpuriousRetransmitDetected(
         unacked_packets_, clock_->Now(), rtt_stats_, info.retransmission);
   }
 }
 
 bool QuicSentPacketManager::HasPendingRetransmissions() const {
   return !pending_retransmissions_.empty();
 }
 
-PendingRetransmission QuicSentPacketManager::NextPendingRetransmission() {
+QuicPendingRetransmission QuicSentPacketManager::NextPendingRetransmission() {
   QUIC_BUG_IF(pending_retransmissions_.empty())
       << "Unexpected call to PendingRetransmissions() with empty pending "
       << "retransmission list. Corrupted memory usage imminent.";
   QuicPacketNumber packet_number = pending_retransmissions_.begin()->first;
   TransmissionType transmission_type = pending_retransmissions_.begin()->second;
   if (unacked_packets_.HasPendingCryptoPackets()) {
     // Ensure crypto packets are retransmitted before other packets.
     for (const auto& pair : pending_retransmissions_) {
       if (HasCryptoHandshake(
               unacked_packets_.GetTransmissionInfo(pair.first))) {
         packet_number = pair.first;
         transmission_type = pair.second;
         break;
       }
     }
   }
   DCHECK(unacked_packets_.IsUnacked(packet_number)) << packet_number;
-  const TransmissionInfo& transmission_info =
+  const QuicTransmissionInfo& transmission_info =
       unacked_packets_.GetTransmissionInfo(packet_number);
   DCHECK(!transmission_info.retransmittable_frames.empty());
 
-  return PendingRetransmission(path_id_, packet_number, transmission_type,
-                               transmission_info.retransmittable_frames,
-                               transmission_info.has_crypto_handshake,
-                               transmission_info.num_padding_bytes,
-                               transmission_info.encryption_level,
-                               transmission_info.packet_number_length);
+  return QuicPendingRetransmission(path_id_, packet_number, transmission_type,
+                                   transmission_info.retransmittable_frames,
+                                   transmission_info.has_crypto_handshake,
+                                   transmission_info.num_padding_bytes,
+                                   transmission_info.encryption_level,
+                                   transmission_info.packet_number_length);
 }
 
 QuicPacketNumber QuicSentPacketManager::GetNewestRetransmission(
     QuicPacketNumber packet_number,
-    const TransmissionInfo& transmission_info) const {
+    const QuicTransmissionInfo& transmission_info) const {
   QuicPacketNumber retransmission = transmission_info.retransmission;
   while (retransmission != 0) {
     packet_number = retransmission;
     retransmission =
         unacked_packets_.GetTransmissionInfo(retransmission).retransmission;
   }
   return packet_number;
 }
 
 void QuicSentPacketManager::MarkPacketNotRetransmittable(
     QuicPacketNumber packet_number,
     QuicTime::Delta ack_delay_time) {
   if (!unacked_packets_.IsUnacked(packet_number)) {
     return;
   }
 
-  const TransmissionInfo& transmission_info =
+  const QuicTransmissionInfo& transmission_info =
       unacked_packets_.GetTransmissionInfo(packet_number);
   QuicPacketNumber newest_transmission =
       GetNewestRetransmission(packet_number, transmission_info);
   // We do not need to retransmit this packet anymore.
   if (delegate_ != nullptr) {
     delegate_->OnPacketMarkedNotRetransmittable(path_id_, newest_transmission,
                                                 ack_delay_time);
   } else {
     pending_retransmissions_.erase(newest_transmission);
   }
 
   unacked_packets_.NotifyAndClearListeners(newest_transmission, ack_delay_time);
   unacked_packets_.RemoveRetransmittability(packet_number);
 }
 
 void QuicSentPacketManager::MarkPacketHandled(QuicPacketNumber packet_number,
-                                              TransmissionInfo* info,
+                                              QuicTransmissionInfo* info,
                                               QuicTime::Delta ack_delay_time) {
   QuicPacketNumber newest_transmission =
       GetNewestRetransmission(packet_number, *info);
   // Remove the most recent packet, if it is pending retransmission.
   if (delegate_ != nullptr) {
     delegate_->OnPacketMarkedHandled(path_id_, newest_transmission,
                                      ack_delay_time);
   } else {
     pending_retransmissions_.erase(newest_transmission);
   }
 
   // The AckListener needs to be notified about the most recent
   // transmission, since that's the one only one it tracks.
   if (newest_transmission == packet_number) {
     unacked_packets_.NotifyAndClearListeners(&info->ack_listeners,
                                              ack_delay_time);
   } else {
     unacked_packets_.NotifyAndClearListeners(newest_transmission,
                                              ack_delay_time);
     RecordSpuriousRetransmissions(*info, packet_number);
     // Remove the most recent packet from flight if it's a crypto handshake
     // packet, since they won't be acked now that one has been processed.
     // Other crypto handshake packets won't be in flight, only the newest
     // transmission of a crypto packet is in flight at once.
     // TODO(ianswett): Instead of handling all crypto packets special,
     // only handle nullptr encrypted packets in a special way.
-    const TransmissionInfo& newest_transmission_info =
+    const QuicTransmissionInfo& newest_transmission_info =
         unacked_packets_.GetTransmissionInfo(newest_transmission);
     if (HasCryptoHandshake(newest_transmission_info)) {
       unacked_packets_.RemoveFromInFlight(newest_transmission);
     }
   }
 
   if (network_change_visitor_ != nullptr &&
       info->bytes_sent > largest_mtu_acked_) {
     largest_mtu_acked_ = info->bytes_sent;
     network_change_visitor_->OnPathMtuIncreased(largest_mtu_acked_);
@@ skipping 210 matching lines @@
                                            QuicTime ack_receive_time) {
   // We rely on ack_delay_time to compute an RTT estimate, so we
   // only update rtt when the largest observed gets acked.
   // NOTE: If ack is a truncated ack, then the largest observed is in fact
   // unacked, and may cause an RTT sample to be taken.
   if (!unacked_packets_.IsUnacked(ack_frame.largest_observed)) {
     return false;
   }
   // We calculate the RTT based on the highest ACKed packet number, the lower
   // packet numbers will include the ACK aggregation delay.
-  const TransmissionInfo& transmission_info =
+  const QuicTransmissionInfo& transmission_info =
       unacked_packets_.GetTransmissionInfo(ack_frame.largest_observed);
   // Ensure the packet has a valid sent time.
   if (transmission_info.sent_time == QuicTime::Zero()) {
     QUIC_BUG << "Acked packet has zero sent time, largest_observed:"
              << ack_frame.largest_observed;
     return false;
   }
 
   QuicTime::Delta send_delta = ack_receive_time - transmission_info.sent_time;
   const int kMaxSendDeltaSeconds = 30;
@@ skipping 245 matching lines @@
 }
 
 size_t QuicSentPacketManager::GetConsecutiveRtoCount() const {
   return consecutive_rto_count_;
 }
 
 size_t QuicSentPacketManager::GetConsecutiveTlpCount() const {
   return consecutive_tlp_count_;
 }
 
-TransmissionInfo* QuicSentPacketManager::GetMutableTransmissionInfo(
+QuicTransmissionInfo* QuicSentPacketManager::GetMutableTransmissionInfo(
     QuicPacketNumber packet_number) {
   return unacked_packets_.GetMutableTransmissionInfo(packet_number);
 }
 
 void QuicSentPacketManager::RemoveObsoletePackets() {
   unacked_packets_.RemoveObsoletePackets();
 }
 
 void QuicSentPacketManager::OnApplicationLimited() {
   send_algorithm_->OnApplicationLimited(unacked_packets_.bytes_in_flight());
 }
 
+const SendAlgorithmInterface* QuicSentPacketManager::GetSendAlgorithm() const {
+  return send_algorithm_.get();
+}
+
 }  // namespace net