Land Recent QUIC Changes.

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"
@@ skipping 99 matching lines @@
           QuicTime::Delta::FromSeconds(FLAGS_quic_recent_min_rtt_window_s));
     }
     send_algorithm_.reset(
         SendAlgorithmInterface::Create(clock_, &rtt_stats_, kBBR, stats_));
   }
   if (config.HasReceivedConnectionOptions() &&
       ContainsQuicTag(config.ReceivedConnectionOptions(), kRENO)) {
     send_algorithm_.reset(
         SendAlgorithmInterface::Create(clock_, &rtt_stats_, kReno, stats_));
   }
-  if (is_server_) {
-    if (config.HasReceivedConnectionOptions() &&
-        ContainsQuicTag(config.ReceivedConnectionOptions(), kPACE)) {
-      EnablePacing();
-    }
-  } else if (config.HasSendConnectionOptions() &&
-             ContainsQuicTag(config.SendConnectionOptions(), kPACE)) {
+  if (HasClientSentConnectionOption(config, kPACE)) {
     EnablePacing();
   }
-  // TODO(ianswett): Remove the "HasReceivedLossDetection" branch once
-  // the ConnectionOptions code is live everywhere.
+  if (HasClientSentConnectionOption(config, k1CON)) {
+    send_algorithm_->SetNumEmulatedConnections(1);
+  }
   if (config.HasReceivedConnectionOptions() &&
       ContainsQuicTag(config.ReceivedConnectionOptions(), kTIME)) {
     loss_algorithm_.reset(LossDetectionInterface::Create(kTime));
   }
   send_algorithm_->SetFromConfig(config, is_server_);
 
   if (network_change_visitor_ != NULL) {
     network_change_visitor_->OnCongestionWindowChange(GetCongestionWindow());
   }
 }
 
-// TODO(ianswett): Combine this method with OnPacketSent once packets are always
-// sent in order and the connection tracks RetransmittableFrames for longer.
-void QuicSentPacketManager::OnSerializedPacket(
-    const SerializedPacket& serialized_packet) {
-  if (serialized_packet.retransmittable_frames) {
-    ack_notifier_manager_.OnSerializedPacket(serialized_packet);
+bool QuicSentPacketManager::HasClientSentConnectionOption(
+    const QuicConfig& config, QuicTag tag) const {
+  if (is_server_) {
+    if (config.HasReceivedConnectionOptions() &&
+        ContainsQuicTag(config.ReceivedConnectionOptions(), tag)) {
+      return true;
+    }
+  } else if (config.HasSendConnectionOptions() &&
+             ContainsQuicTag(config.SendConnectionOptions(), tag)) {
+    return true;
   }
-  unacked_packets_.AddPacket(serialized_packet);
-
-  if (debug_delegate_ != NULL) {
-    // TODO(ianswett): Merge calls in the debug delegate.
-    debug_delegate_->OnSerializedPacket(serialized_packet);
-  }
+  return false;
 }
 
 void QuicSentPacketManager::OnRetransmittedPacket(
     QuicPacketSequenceNumber old_sequence_number,
     QuicPacketSequenceNumber new_sequence_number) {
   TransmissionType transmission_type;
   PendingRetransmissionMap::iterator it =
       pending_retransmissions_.find(old_sequence_number);
   if (it != pending_retransmissions_.end()) {
     transmission_type = it->second;
     pending_retransmissions_.erase(it);
   } else {
     DLOG(DFATAL) << "Expected sequence number to be in "
         "pending_retransmissions_.  sequence_number: " << old_sequence_number;
     transmission_type = NOT_RETRANSMISSION;
   }
 
   // A notifier may be waiting to hear about ACKs for the original sequence
   // number. Inform them that the sequence number has changed.
   ack_notifier_manager_.UpdateSequenceNumber(old_sequence_number,
                                              new_sequence_number);
 
   unacked_packets_.OnRetransmittedPacket(old_sequence_number,
                                          new_sequence_number,
                                          transmission_type);
-
-  if (debug_delegate_ != NULL) {
-    debug_delegate_->OnRetransmittedPacket(old_sequence_number,
-        new_sequence_number,
-        transmission_type,
-        clock_->ApproximateNow());
-  }
 }
 
 void QuicSentPacketManager::OnIncomingAck(const QuicAckFrame& ack_frame,
                                           QuicTime ack_receive_time) {
   QuicByteCount bytes_in_flight = unacked_packets_.bytes_in_flight();
 
   UpdatePacketInformationReceivedByPeer(ack_frame);
   // We rely on delta_time_largest_observed to compute an RTT estimate, so
   // we only update rtt when the largest observed gets acked.
   bool largest_observed_acked = MaybeUpdateRTT(ack_frame, ack_receive_time);
@@ skipping 310 matching lines @@
     SerializedPacket* serialized_packet,
     QuicPacketSequenceNumber original_sequence_number,
     QuicTime sent_time,
     QuicByteCount bytes,
     TransmissionType transmission_type,
     HasRetransmittableData has_retransmittable_data) {
   QuicPacketSequenceNumber sequence_number = serialized_packet->sequence_number;
   DCHECK_LT(0u, sequence_number);
   DCHECK(!unacked_packets_.IsUnacked(sequence_number));
   LOG_IF(DFATAL, bytes == 0) << "Cannot send empty packets.";
+  if (debug_delegate_ != NULL) {
+    debug_delegate_->OnSentPacket(*serialized_packet,
+                                  original_sequence_number,
+                                  sent_time,
+                                  bytes,
+                                  transmission_type);
+  }
+
   if (original_sequence_number == 0) {
-    OnSerializedPacket(*serialized_packet);
+    if (serialized_packet->retransmittable_frames) {
+      ack_notifier_manager_.OnSerializedPacket(*serialized_packet);
+    }
+    unacked_packets_.AddPacket(*serialized_packet);
     serialized_packet->retransmittable_frames = NULL;
   } else {
     OnRetransmittedPacket(original_sequence_number, sequence_number);
   }
 
   if (pending_timer_transmission_count_ > 0) {
     --pending_timer_transmission_count_;
   }
 
   if (unacked_packets_.bytes_in_flight() == 0) {
     // TODO(ianswett): Consider being less aggressive to force a new
     // recent_min_rtt, likely by not discarding a relatively new sample.
     DVLOG(1) << "Sampling a new recent min rtt within 2 samples. currently:"
              << rtt_stats_.recent_min_rtt().ToMilliseconds() << "ms";
     rtt_stats_.SampleNewRecentMinRtt(kNumMinRttSamplesAfterQuiescence);
   }
 
   // Only track packets as in flight that the send algorithm wants us to track.
   const bool in_flight =
       send_algorithm_->OnPacketSent(sent_time,
                                     unacked_packets_.bytes_in_flight(),
                                     sequence_number,
                                     bytes,
                                     has_retransmittable_data);
   unacked_packets_.SetSent(sequence_number, sent_time, bytes, in_flight);
 
-  if (debug_delegate_ != NULL) {
-    debug_delegate_->OnSentPacket(
-        sequence_number, sent_time, bytes, transmission_type);
-  }
-
   // 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 325 matching lines @@
 
   // Set up a pacing sender with a 5 millisecond alarm granularity.
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMilliseconds(5),
                        kInitialUnpacedBurst));
 }
 
 }  // namespace net