Landing Recent QUIC changes until 01/28/2016 18:41 UTC

net/quic/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/quic_sent_packet_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/quic/congestion_control/pacing_sender.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/proto/cached_network_parameters.pb.h"
 #include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_connection_stats.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils_chromium.h"
 
 using std::max;
 using std::min;
+using std::pair;
 
 namespace net {
 
 // The length of the recent min rtt window in seconds. Windowing is disabled for
 // values less than or equal to 0.
 int32_t FLAGS_quic_recent_min_rtt_window_s = 60;
 
 namespace {
 static const int64_t kDefaultRetransmissionTimeMs = 500;
 // TCP RFC calls for 1 second RTO however Linux differs from this default and
@@ skipping 58 matching lines @@
       least_packet_awaited_by_peer_(1),
       first_rto_transmission_(0),
       consecutive_rto_count_(0),
       consecutive_tlp_count_(0),
       consecutive_crypto_retransmission_count_(0),
       pending_timer_transmission_count_(0),
       max_tail_loss_probes_(kDefaultMaxTailLossProbes),
       enable_half_rtt_tail_loss_probe_(false),
       using_pacing_(false),
       use_new_rto_(false),
-      handshake_confirmed_(false),
-      use_general_loss_algorithm_(FLAGS_quic_general_loss_algorithm) {}
+      handshake_confirmed_(false) {}
 
 QuicSentPacketManager::~QuicSentPacketManager() {}
 
 void QuicSentPacketManager::SetFromConfig(const QuicConfig& config) {
   if (config.HasReceivedInitialRoundTripTimeUs() &&
       config.ReceivedInitialRoundTripTimeUs() > 0) {
     rtt_stats_.set_initial_rtt_us(
         max(kMinInitialRoundTripTimeUs,
             min(kMaxInitialRoundTripTimeUs,
                 config.ReceivedInitialRoundTripTimeUs())));
@@ skipping 465 matching lines @@
       serialized_packet->is_fec_packet ? HAS_RETRANSMITTABLE_DATA
                                        : has_retransmittable_data;
   // TODO(ianswett): Remove sent_time, because it's unused.
   const bool in_flight = send_algorithm_->OnPacketSent(
       sent_time, unacked_packets_.bytes_in_flight(), packet_number, bytes,
       has_congestion_controlled_data);
 
   unacked_packets_.AddSentPacket(serialized_packet, original_packet_number,
                                  transmission_type, sent_time, bytes,
                                  in_flight);
-
-  // Take ownership of the retransmittable frames before exiting.
-  serialized_packet->retransmittable_frames = nullptr;
   // Reset the retransmission timer anytime a pending packet is sent.
   return in_flight;
 }
 
 void QuicSentPacketManager::OnRetransmissionTimeout() {
   DCHECK(unacked_packets_.HasInFlightPackets());
   DCHECK_EQ(0u, pending_timer_transmission_count_);
   // Handshake retransmission, timer based loss detection, TLP, and RTO are
   // implemented with a single alarm. The handshake alarm is set when the
   // handshake has not completed, the loss alarm is set when the loss detection
@@ skipping 114 matching lines @@
   }
   if (consecutive_tlp_count_ < max_tail_loss_probes_) {
     if (unacked_packets_.HasUnackedRetransmittableFrames()) {
       return TLP_MODE;
     }
   }
   return RTO_MODE;
 }
 
 void QuicSentPacketManager::InvokeLossDetection(QuicTime time) {
-  if (use_general_loss_algorithm_) {
-    loss_algorithm_->DetectLosses(unacked_packets_, time, rtt_stats_,
-                                  &packets_lost_);
-    for (const std::pair<QuicPacketNumber, QuicByteCount>& pair :
-         packets_lost_) {
-      ++stats_->packets_lost;
-      if (FLAGS_quic_log_loss_event && debug_delegate_ != nullptr) {
-        debug_delegate_->OnPacketLoss(pair.first, LOSS_RETRANSMISSION, time);
-      }
+  loss_algorithm_->DetectLosses(unacked_packets_, time, rtt_stats_,
+                                &packets_lost_);
+  for (const pair<QuicPacketNumber, QuicByteCount>& pair : packets_lost_) {
+    ++stats_->packets_lost;
+    if (FLAGS_quic_log_loss_event && debug_delegate_ != nullptr) {
+      debug_delegate_->OnPacketLoss(pair.first, LOSS_RETRANSMISSION, time);
+    }
 
-      // TODO(ianswett): This could be optimized.
-      if (unacked_packets_.HasRetransmittableFrames(pair.first)) {
-        MarkForRetransmission(pair.first, LOSS_RETRANSMISSION);
-      } else {
-        // Since we will not retransmit this, we need to remove it from
-        // unacked_packets_.   This is either the current transmission of
-        // a packet whose previous transmission has been acked, a packet that
-        // has been TLP retransmitted, or an FEC packet.
-        unacked_packets_.RemoveFromInFlight(pair.first);
-      }
-    }
-    return;
-  }
-  PacketNumberSet lost_packets = loss_algorithm_->DetectLostPackets(
-      unacked_packets_, time, unacked_packets_.largest_observed(), rtt_stats_);
-  for (PacketNumberSet::const_iterator it = lost_packets.begin();
-       it != lost_packets.end(); ++it) {
-    QuicPacketNumber packet_number = *it;
-    const TransmissionInfo& transmission_info =
-        unacked_packets_.GetTransmissionInfo(packet_number);
-    // TODO(ianswett): If it's expected the FEC packet may repair the loss, it
-    // should be recorded as a loss to the send algorithm, but not retransmitted
-    // until it's known whether the FEC packet arrived.
-    ++stats_->packets_lost;
-    packets_lost_.push_back(
-        std::make_pair(packet_number, transmission_info.bytes_sent));
-    DVLOG(1) << ENDPOINT << "Lost packet " << packet_number;
-
-    if (!transmission_info.retransmittable_frames.empty()) {
-      MarkForRetransmission(packet_number, LOSS_RETRANSMISSION);
+    // TODO(ianswett): This could be optimized.
+    if (unacked_packets_.HasRetransmittableFrames(pair.first)) {
+      MarkForRetransmission(pair.first, LOSS_RETRANSMISSION);
     } else {
       // Since we will not retransmit this, we need to remove it from
       // unacked_packets_.   This is either the current transmission of
-      // a packet whose previous transmission has been acked, a packet that has
-      // been TLP retransmitted, or an FEC packet.
-      unacked_packets_.RemoveFromInFlight(packet_number);
+      // a packet whose previous transmission has been acked, a packet that
+      // has been TLP retransmitted, or an FEC packet.
+      unacked_packets_.RemoveFromInFlight(pair.first);
     }
   }
 }
 
 bool QuicSentPacketManager::MaybeUpdateRTT(const QuicAckFrame& ack_frame,
                                            const 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.
@@ skipping 225 matching lines @@
 TransmissionInfo* QuicSentPacketManager::GetMutableTransmissionInfo(
     QuicPacketNumber packet_number) {
   return unacked_packets_.GetMutableTransmissionInfo(packet_number);
 }
 
 void QuicSentPacketManager::RemoveObsoletePackets() {
   unacked_packets_.RemoveObsoletePackets();
 }
 
 }  // namespace net